Merge branch 'main' into claude/fix-missing-file-dep-error-message

The error message format changed from "error occurred while resolving"
to "failed to resolve" - update test to match.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/install/PackageManager/PackageManagerEnqueue.zig

@@ -621,6 +621,40 @@ pub fn enqueueDependencyWithMainAndSuccessFn(
                                 }
                                 return;
                             },
+                            error.MissingPackageJSON => {
+                                if (dependency.behavior.isRequired()) {
+                                    if (failFn) |fail| {
+                                        fail(
+                                            this,
+                                            dependency,
+                                            id,
+                                            err,
+                                        );
+                                    } else if (version.tag == .folder) {
+                                        this.log.addErrorFmt(
+                                            null,
+                                            logger.Loc.Empty,
+                                            this.allocator,
+                                            "Could not find package.json for \"file:{s}\" dependency \"{s}\"",
+                                            .{
+                                                this.lockfile.str(&version.value.folder),
+                                                this.lockfile.str(&name),
+                                            },
+                                        ) catch unreachable;
+                                    } else {
+                                        this.log.addErrorFmt(
+                                            null,
+                                            logger.Loc.Empty,
+                                            this.allocator,
+                                            "Could not find package.json for dependency \"{s}\"",
+                                            .{
+                                                this.lockfile.str(&name),
+                                            },
+                                        ) catch unreachable;
+                                    }
+                                }
+                                return;
+                            },
                             else => {
                                 if (failFn) |fail| {
                                     fail(

test/cli/install/bun-add.test.ts

@@ -111,8 +111,8 @@ it("should reject missing package", async () => {
     env,
   });
   const err = await stderr.text();
-  expect(err).toContain("error: MissingPackageJSON");
-  expect(err).toContain(`note: error occurred while resolving file:${add_path}`);
+  expect(err).toContain(`error: Could not find package.json for "file:${add_path}" dependency`);
+  expect(err).toContain("failed to resolve");
 
   const out = await stdout.text();
   expect(out).toEqual(expect.stringContaining("bun add v1."));

test/regression/issue/26337.test.ts

@@ -67,10 +67,11 @@ describe("issue #26337 - missing file: dependency error should show dependency n
       failProc.exited,
     ]);
 
-    // The error output should mention the dependency name
+    // The error output should mention the dependency name and path
     const output = stdout + stderr;
     expect(output).toContain("@scope/dep");
-    expect(output).toContain("error occurred while resolving");
+    expect(output).toContain("file:./nonexistent/path");
+    expect(output).toContain("failed to resolve");
 
     // The install should fail
     expect(exitCode).toBe(1);

test/regression/issue/26338.test.ts

@@ -0,0 +1,57 @@
+// https://github.com/oven-sh/bun/issues/26338
+// Test that when a lockfile references a stale file: dependency path,
+// the error message correctly identifies the missing dependency path
+// instead of showing "Bun could not find a package.json file to install from"
+
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+
+test("shows informative error for missing file: dependency path", async () => {
+  // Create a directory structure where:
+  // - package.json references a path that doesn't exist
+  // - bun.lock references a different (also non-existent) path
+  // This simulates a stale lockfile scenario
+  using dir = tempDir("missing-file-dep", {
+    "package.json": JSON.stringify({
+      name: "app",
+      version: "1.0.0",
+      dependencies: {
+        dep: "file:../packages/@scope/dep",
+      },
+    }),
+    "bun.lock": JSON.stringify({
+      lockfileVersion: 1,
+      configVersion: 1,
+      workspaces: {
+        "": {
+          name: "app",
+          dependencies: {
+            dep: "file:../dep",
+          },
+        },
+      },
+      packages: {
+        dep: ["dep@file:../dep", {}],
+      },
+    }),
+  });
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "install"],
+    cwd: String(dir),
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+  // The error should mention the file: path, not a generic "package.json not found" message
+  expect(stderr).toContain("file:../packages/@scope/dep");
+  // Check that the dependency name "dep" appears as a quoted token (not just as part of "dependency")
+  expect(stderr).toMatch(/"dep"/);
+  expect(stderr).not.toContain("Bun could not find a package.json file to install from");
+  expect(stderr).not.toContain('Run "bun init" to initialize a project');
+
+  expect(exitCode).not.toBe(0);
+});