Merge branch 'main' into jarred/esm-conditionsjarred/esm-conditions

8 files changed, 553 insertions, 91 deletions

diff --git a/test/cli/install/bun-add.test.ts b/test/cli/install/bun-add.test.ts
index 79804f0e0..9dd38c8cd 100644
--- a/test/cli/install/bun-add.test.ts
+++ b/test/cli/install/bun-add.test.ts
@@ -303,6 +303,61 @@ it("should add dependency with capital letters", async () => {
   await access(join(package_dir, "bun.lockb"));
 });
 
+it("should add exact version", async () => {
+  const urls: string[] = [];
+  setHandler(dummyRegistry(urls));
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({
+      name: "foo",
+      version: "0.0.1",
+    }),
+  );
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "add", "--exact", "BaR"],
+    cwd: package_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+  expect(stderr).toBeDefined();
+  const err = await new Response(stderr).text();
+  expect(err).toContain("Saved lockfile");
+  expect(stdout).toBeDefined();
+  const out = await new Response(stdout).text();
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    "",
+    " installed BaR@0.0.2",
+    "",
+    "",
+    " 1 packages installed",
+  ]);
+  expect(await exited).toBe(0);
+  expect(urls.sort()).toEqual([`${root_url}/BaR`, `${root_url}/BaR-0.0.2.tgz`]);
+  expect(requested).toBe(2);
+  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "BaR"]);
+  expect(await readdirSorted(join(package_dir, "node_modules", "BaR"))).toEqual(["package.json"]);
+  expect(await file(join(package_dir, "node_modules", "BaR", "package.json")).json()).toEqual({
+    name: "bar",
+    version: "0.0.2",
+  });
+  expect(await file(join(package_dir, "package.json")).text()).toEqual(
+    JSON.stringify(
+      {
+        name: "foo",
+        version: "0.0.1",
+        dependencies: {
+          BaR: "0.0.2",
+        },
+      },
+      null,
+      2,
+    ),
+  );
+  await access(join(package_dir, "bun.lockb"));
+});
+
 it("should add dependency with specified semver", async () => {
   const urls: string[] = [];
   setHandler(
diff --git a/test/cli/install/bun-install.test.ts b/test/cli/install/bun-install.test.ts
index f44dc5a7e..f2483c8d2 100644
--- a/test/cli/install/bun-install.test.ts
+++ b/test/cli/install/bun-install.test.ts
@@ -1,7 +1,7 @@
 import { file, listen, Socket, spawn } from "bun";
 import { afterAll, afterEach, beforeAll, beforeEach, expect, it } from "bun:test";
 import { bunExe, bunEnv as env } from "harness";
-import { access, mkdir, readlink, rm, writeFile } from "fs/promises";
+import { access, mkdir, readlink, realpath, rm, writeFile } from "fs/promises";
 import { join } from "path";
 import {
   dummyAfterAll,
@@ -292,6 +292,50 @@ it("should handle workspaces", async () => {
   await access(join(package_dir, "bun.lockb"));
 });
 
+it("should handle `workspace:` specifier", async () => {
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({
+      name: "Foo",
+      version: "0.0.1",
+      dependencies: {
+        Bar: "workspace:path/to/bar",
+      },
+    }),
+  );
+  await mkdir(join(package_dir, "path", "to", "bar"), { recursive: true });
+  await writeFile(
+    join(package_dir, "path", "to", "bar", "package.json"),
+    JSON.stringify({
+      name: "Bar",
+      version: "0.0.2",
+    }),
+  );
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "install"],
+    cwd: package_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+  expect(stderr).toBeDefined();
+  const err = await new Response(stderr).text();
+  expect(err).toContain("Saved lockfile");
+  expect(stdout).toBeDefined();
+  const out = await new Response(stdout).text();
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    " + Bar@workspace:path/to/bar",
+    "",
+    " 1 packages installed",
+  ]);
+  expect(await exited).toBe(0);
+  expect(requested).toBe(0);
+  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "Bar"]);
+  expect(await readlink(join(package_dir, "node_modules", "Bar"))).toBe(join("..", "path", "to", "bar"));
+  await access(join(package_dir, "bun.lockb"));
+});
+
 it("should handle workspaces with packages array", async () => {
   await writeFile(
     join(package_dir, "package.json"),
@@ -4241,6 +4285,55 @@ it("should handle --cwd", async () => {
   });
 });
 
+it("should handle --frozen-lockfile", async () => {
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({ name: "foo", version: "0.0.1", dependencies: { bar: "0.0.2" } }),
+  );
+
+  const { stderr, exited } = spawn({
+    cmd: [bunExe(), "install", "--frozen-lockfile"],
+    cwd: package_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  expect(stderr).toBeDefined();
+  const err = await new Response(stderr).text();
+  expect(err).toContain("error: lockfile had changes, but lockfile is frozen");
+  expect(await exited).toBe(1);
+});
+
+it("should handle frozenLockfile in config file", async () => {
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({ name: "foo", version: "0.0.1", dependencies: { bar: "0.0.2" } }),
+  );
+  await writeFile(
+    join(package_dir, "bunfig.toml"),
+    `
+[install]
+frozenLockfile = true
+`,
+  );
+
+  const { stderr, exited } = spawn({
+    cmd: [bunExe(), "install"],
+    cwd: package_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  expect(stderr).toBeDefined();
+  const err = await new Response(stderr).text();
+  expect(err).toContain("error: lockfile had changes, but lockfile is frozen");
+  expect(await exited).toBe(1);
+});
+
 it("should perform bin-linking across multiple dependencies", async () => {
   const foo_package = JSON.stringify({
     name: "foo",
@@ -4259,7 +4352,11 @@ it("should perform bin-linking across multiple dependencies", async () => {
 cache = false
 `,
   );
-  const { stdout, stderr, exited } = spawn({
+  const {
+    stdout: stdout1,
+    stderr: stderr1,
+    exited: exited1,
+  } = spawn({
     cmd: [bunExe(), "install"],
     cwd: package_dir,
     stdout: null,
@@ -4267,13 +4364,13 @@ cache = false
     stderr: "pipe",
     env,
   });
-  expect(stderr).toBeDefined();
-  const err = await new Response(stderr).text();
-  expect(err).toContain("Saved lockfile");
-  expect(err).not.toContain("error:");
-  expect(stdout).toBeDefined();
-  const out = await new Response(stdout).text();
-  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+  expect(stderr1).toBeDefined();
+  const err1 = await new Response(stderr1).text();
+  expect(err1).toContain("Saved lockfile");
+  expect(err1).not.toContain("error:");
+  expect(stdout1).toBeDefined();
+  const out1 = await new Response(stdout1).text();
+  expect(out1.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
     " + conditional-type-checks@1.0.6",
     " + prettier@2.8.8",
     " + tsd@0.22.0",
@@ -4281,7 +4378,7 @@ cache = false
     "",
     " 119 packages installed",
   ]);
-  expect(await exited).toBe(0);
+  expect(await exited1).toBe(0);
   expect(await readdirSorted(package_dir)).toEqual(["bun.lockb", "bunfig.toml", "node_modules", "package.json"]);
   expect(await file(join(package_dir, "package.json")).text()).toEqual(foo_package);
   expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([
@@ -4394,4 +4491,101 @@ cache = false
     "tsd",
     "tsserver",
   ]);
-}, 10000);
+  // Perform `bun install --production` with lockfile from before
+  await rm(join(package_dir, "node_modules"), { force: true, recursive: true });
+  const {
+    stdout: stdout2,
+    stderr: stderr2,
+    exited: exited2,
+  } = spawn({
+    cmd: [bunExe(), "install", "--production"],
+    cwd: package_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+  expect(stderr2).toBeDefined();
+  const err2 = await new Response(stderr2).text();
+  expect(err2).not.toContain("Saved lockfile");
+  expect(err2).not.toContain("error:");
+  expect(stdout2).toBeDefined();
+  const out2 = await new Response(stdout2).text();
+  expect(out2.replace(/\[[0-9\.]+m?s\]/, "[]").split(/\r?\n/)).toEqual(["[] done", ""]);
+  expect(await exited2).toBe(0);
+  expect(await readdirSorted(package_dir)).toEqual(["bun.lockb", "bunfig.toml", "node_modules", "package.json"]);
+  expect(await file(join(package_dir, "package.json")).text()).toEqual(foo_package);
+  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([]);
+}, 20000);
+
+it("should handle trustedDependencies", async () => {
+  const scripts = {
+    preinstall: `${bunExe()} echo.js preinstall`,
+    install: `${bunExe()} echo.js install`,
+    postinstall: `${bunExe()} echo.js postinstall`,
+    preprepare: `${bunExe()} echo.js preprepare`,
+    prepare: `${bunExe()} echo.js prepare`,
+    postprepare: `${bunExe()} echo.js postprepare`,
+  };
+  await writeFile(
+    join(package_dir, "package.json"),
+    JSON.stringify({
+      name: "foo",
+      version: "0.1.0",
+      dependencies: {
+        bar: "file:./bar",
+        moo: "file:./moo",
+      },
+      trustedDependencies: ["moo"],
+    }),
+  );
+  await mkdir(join(package_dir, "bar"));
+  const bar_package = JSON.stringify({
+    name: "bar",
+    version: "0.2.0",
+    scripts,
+  });
+  await writeFile(join(package_dir, "bar", "package.json"), bar_package);
+  await writeFile(join(package_dir, "bar", "echo.js"), "console.log(`bar|${process.argv[2]}|${import.meta.dir}`);");
+  await mkdir(join(package_dir, "moo"));
+  const moo_package = JSON.stringify({
+    name: "moo",
+    version: "0.3.0",
+    scripts,
+  });
+  await writeFile(join(package_dir, "moo", "package.json"), moo_package);
+  await writeFile(join(package_dir, "moo", "echo.js"), "console.log(`moo|${process.argv[2]}|${import.meta.dir}`);");
+  const { stdout, stderr, exited } = spawn({
+    cmd: [bunExe(), "install"],
+    cwd: package_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env,
+  });
+  expect(stderr).toBeDefined();
+  const err = await new Response(stderr).text();
+  expect(err).toContain("Saved lockfile");
+  expect(stdout).toBeDefined();
+  const out = await new Response(stdout).text();
+  const moo_dir = await realpath(join(package_dir, "node_modules", "moo"));
+  expect(out.replace(/\s*\[[0-9\.]+m?s\]\s*$/, "").split(/\r?\n/)).toEqual([
+    `moo|preinstall|${moo_dir}`,
+    " + bar@bar",
+    " + moo@moo",
+    `moo|install|${moo_dir}`,
+    `moo|postinstall|${moo_dir}`,
+    `moo|preprepare|${moo_dir}`,
+    `moo|prepare|${moo_dir}`,
+    `moo|postprepare|${moo_dir}`,
+    "",
+    " 2 packages installed",
+  ]);
+  expect(await exited).toBe(0);
+  expect(await readdirSorted(join(package_dir, "node_modules"))).toEqual([".cache", "bar", "moo"]);
+  expect(await readdirSorted(join(package_dir, "node_modules", "bar"))).toEqual(["echo.js", "package.json"]);
+  expect(await file(join(package_dir, "node_modules", "bar", "package.json")).text()).toEqual(bar_package);
+  expect(await readdirSorted(join(package_dir, "node_modules", "moo"))).toEqual(["echo.js", "package.json"]);
+  expect(await file(join(package_dir, "node_modules", "moo", "package.json")).text()).toEqual(moo_package);
+  await access(join(package_dir, "bun.lockb"));
+});
diff --git a/test/cli/install/bun-run.test.ts b/test/cli/install/bun-run.test.ts
new file mode 100644
index 000000000..95f33ebb8
--- /dev/null
+++ b/test/cli/install/bun-run.test.ts
@@ -0,0 +1,172 @@
+import { file, spawn } from "bun";
+import { afterEach, beforeEach, expect, it } from "bun:test";
+import { bunExe, bunEnv as env } from "harness";
+import { mkdtemp, realpath, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { readdirSorted } from "./dummy.registry";
+
+let run_dir: string;
+
+beforeEach(async () => {
+  run_dir = await realpath(await mkdtemp(join(tmpdir(), "bun-run.test")));
+});
+afterEach(async () => {
+  await rm(run_dir, { force: true, recursive: true });
+});
+
+it("should download dependency to run local file", async () => {
+  await writeFile(
+    join(run_dir, "test.js"),
+    `
+const { minify } = require("uglify-js@3.17.4");
+
+console.log(minify("print(6 * 7)").code);
+  `,
+  );
+  const {
+    stdout: stdout1,
+    stderr: stderr1,
+    exited: exited1,
+  } = spawn({
+    cmd: [bunExe(), "run", "test.js"],
+    cwd: run_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env: {
+      ...env,
+      BUN_INSTALL_CACHE_DIR: join(run_dir, ".cache"),
+    },
+  });
+  expect(stderr1).toBeDefined();
+  const err1 = await new Response(stderr1).text();
+  expect(err1).toBe("");
+  expect(await readdirSorted(run_dir)).toEqual([".cache", "test.js"]);
+  expect(await readdirSorted(join(run_dir, ".cache"))).toContain("uglify-js");
+  expect(await readdirSorted(join(run_dir, ".cache", "uglify-js"))).toEqual(["3.17.4"]);
+  expect(stdout1).toBeDefined();
+  const out1 = await new Response(stdout1).text();
+  expect(out1.split(/\r?\n/)).toEqual(["print(42);", ""]);
+  expect(await exited1).toBe(0);
+  // Perform `bun test.js` with cached dependencies
+  const {
+    stdout: stdout2,
+    stderr: stderr2,
+    exited: exited2,
+  } = spawn({
+    cmd: [bunExe(), "test.js"],
+    cwd: run_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env: {
+      ...env,
+      BUN_INSTALL_CACHE_DIR: join(run_dir, ".cache"),
+    },
+  });
+  expect(stderr2).toBeDefined();
+  const err2 = await new Response(stderr2).text();
+  expect(err2).toBe("");
+  expect(await readdirSorted(run_dir)).toEqual([".cache", "test.js"]);
+  expect(await readdirSorted(join(run_dir, ".cache"))).toContain("uglify-js");
+  expect(await readdirSorted(join(run_dir, ".cache", "uglify-js"))).toEqual(["3.17.4"]);
+  expect(stdout2).toBeDefined();
+  const out2 = await new Response(stdout2).text();
+  expect(out2.split(/\r?\n/)).toEqual(["print(42);", ""]);
+  expect(await exited2).toBe(0);
+});
+
+it("should download dependencies to run local file", async () => {
+  await writeFile(
+    join(run_dir, "test.js"),
+    `
+import { file } from "bun";
+import decompress from "decompress@4.2.1";
+
+const buffer = await file("${join(import.meta.dir, "baz-0.0.3.tgz")}").arrayBuffer();
+for (const entry of await decompress(Buffer.from(buffer))) {
+  console.log(\`\${entry.type}: \${entry.path}\`);
+}
+  `,
+  );
+  const {
+    stdout: stdout1,
+    stderr: stderr1,
+    exited: exited1,
+  } = spawn({
+    cmd: [bunExe(), "test.js"],
+    cwd: run_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env: {
+      ...env,
+      BUN_INSTALL_CACHE_DIR: join(run_dir, ".cache"),
+    },
+  });
+  expect(stderr1).toBeDefined();
+  const err1 = await new Response(stderr1).text();
+  expect(err1).toBe("");
+  expect(await readdirSorted(run_dir)).toEqual([".cache", "test.js"]);
+  expect(await readdirSorted(join(run_dir, ".cache"))).toContain("decompress");
+  expect(await readdirSorted(join(run_dir, ".cache", "decompress"))).toEqual(["4.2.1"]);
+  expect(await readdirSorted(join(run_dir, ".cache", "decompress", "4.2.1"))).toEqual([
+    "index.js",
+    "license",
+    "package.json",
+    "readme.md",
+  ]);
+  expect(await file(join(run_dir, ".cache", "decompress", "4.2.1", "index.js")).text()).toContain(
+    "\nmodule.exports = ",
+  );
+  expect(stdout1).toBeDefined();
+  const out1 = await new Response(stdout1).text();
+  expect(out1.split(/\r?\n/)).toEqual([
+    "directory: package/",
+    "file: package/index.js",
+    "file: package/package.json",
+    "",
+  ]);
+  expect(await exited1).toBe(0);
+  // Perform `bun run test.js` with cached dependencies
+  const {
+    stdout: stdout2,
+    stderr: stderr2,
+    exited: exited2,
+  } = spawn({
+    cmd: [bunExe(), "run", "test.js"],
+    cwd: run_dir,
+    stdout: null,
+    stdin: "pipe",
+    stderr: "pipe",
+    env: {
+      ...env,
+      BUN_INSTALL_CACHE_DIR: join(run_dir, ".cache"),
+    },
+  });
+  expect(stderr2).toBeDefined();
+  const err2 = await new Response(stderr2).text();
+  expect(err2).toBe("");
+  expect(await readdirSorted(run_dir)).toEqual([".cache", "test.js"]);
+  expect(await readdirSorted(join(run_dir, ".cache"))).toContain("decompress");
+  expect(await readdirSorted(join(run_dir, ".cache", "decompress"))).toEqual(["4.2.1"]);
+  expect(await readdirSorted(join(run_dir, ".cache", "decompress", "4.2.1"))).toEqual([
+    "index.js",
+    "license",
+    "package.json",
+    "readme.md",
+  ]);
+  expect(await file(join(run_dir, ".cache", "decompress", "4.2.1", "index.js")).text()).toContain(
+    "\nmodule.exports = ",
+  );
+  expect(stdout2).toBeDefined();
+  const out2 = await new Response(stdout2).text();
+  expect(out2.split(/\r?\n/)).toEqual([
+    "directory: package/",
+    "file: package/index.js",
+    "file: package/package.json",
+    "",
+  ]);
+  expect(await exited2).toBe(0);
+});
diff --git a/test/cli/install/bunx.test.ts b/test/cli/install/bunx.test.ts
index 87ad2f8b4..70d7aac29 100644
--- a/test/cli/install/bunx.test.ts
+++ b/test/cli/install/bunx.test.ts
@@ -1,7 +1,6 @@
 import { spawn } from "bun";
 import { afterEach, beforeEach, expect, it } from "bun:test";
 import { bunExe, bunEnv as env } from "harness";
-import { realpathSync } from "fs";
 import { mkdtemp, realpath, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -10,7 +9,7 @@ import { readdirSorted } from "./dummy.registry";
 let x_dir: string;
 
 beforeEach(async () => {
-  x_dir = realpathSync(await mkdtemp(join(tmpdir(), "bun-x.test")));
+  x_dir = await realpath(await mkdtemp(join(tmpdir(), "bun-x.test")));
 });
 afterEach(async () => {
   await rm(x_dir, { force: true, recursive: true });
@@ -110,75 +109,6 @@ it("should work for @scoped packages", async () => {
   expect(await cached.exited).toBe(0);
 });
 
-it("should download dependency to run local file", async () => {
-  await writeFile(
-    join(x_dir, "test.js"),
-    `
-const { minify } = require("uglify-js@3.17.4");
-
-console.log(minify("print(6 * 7)").code);
-`,
-  );
-  const { stdout, stderr, exited } = spawn({
-    cmd: [bunExe(), "test.js"],
-    cwd: x_dir,
-    stdout: null,
-    stdin: "pipe",
-    stderr: "pipe",
-    env: {
-      ...env,
-      BUN_INSTALL_CACHE_DIR: join(x_dir, ".cache"),
-    },
-  });
-  expect(stderr).toBeDefined();
-  const err = await new Response(stderr).text();
-  expect(err).toBe("");
-  expect(stdout).toBeDefined();
-  const out = await new Response(stdout).text();
-  expect(out.split(/\r?\n/)).toEqual(["print(42);", ""]);
-  expect(await exited).toBe(0);
-  expect(await readdirSorted(x_dir)).toEqual([".cache", "test.js"]);
-});
-
-it("should download dependencies to run local file", async () => {
-  await writeFile(
-    join(x_dir, "test.js"),
-    `
-import { file } from "bun";
-import decompress from "decompress@4.2.1";
-
-const buffer = await file("${join(import.meta.dir, "baz-0.0.3.tgz")}").arrayBuffer();
-for (const entry of await decompress(Buffer.from(buffer))) {
-  console.log(\`\${entry.type}: \${entry.path}\`);
-}
-`,
-  );
-  const { stdout, stderr, exited } = spawn({
-    cmd: [bunExe(), "test.js"],
-    cwd: x_dir,
-    stdout: null,
-    stdin: "pipe",
-    stderr: "pipe",
-    env: {
-      ...env,
-      BUN_INSTALL_CACHE_DIR: join(x_dir, ".cache"),
-    },
-  });
-  expect(stderr).toBeDefined();
-  const err = await new Response(stderr).text();
-  expect(err).toBe("");
-  expect(stdout).toBeDefined();
-  const out = await new Response(stdout).text();
-  expect(out.split(/\r?\n/)).toEqual([
-    "directory: package/",
-    "file: package/index.js",
-    "file: package/package.json",
-    "",
-  ]);
-  expect(await exited).toBe(0);
-  expect(await readdirSorted(x_dir)).toEqual([".cache", "test.js"]);
-});
-
 it("should execute from current working directory", async () => {
   await writeFile(
     join(x_dir, "test.js"),
diff --git a/test/cli/run/env.test.ts b/test/cli/run/env.test.ts
index ddc316f05..e6ee99dd2 100644
--- a/test/cli/run/env.test.ts
+++ b/test/cli/run/env.test.ts
@@ -194,6 +194,51 @@ describe("dotenv priority", () => {
   });
 });
 
+test(".env colon assign", () => {
+  const dir = tempDirWithFiles("dotenv-colon", {
+    ".env": "FOO: foo",
+    "index.ts": "console.log(process.env.FOO);",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("foo");
+});
+
+test(".env export assign", () => {
+  const dir = tempDirWithFiles("dotenv-export", {
+    ".env": "export FOO = foo\nexport = bar",
+    "index.ts": "console.log(process.env.FOO, process.env.export);",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("foo bar");
+});
+
+test(".env value expansion", () => {
+  const dir = tempDirWithFiles("dotenv-expand", {
+    ".env": "FOO=foo\nBAR=$FOO bar\nMOO=${FOO} ${BAR:-fail} ${MOZ:-moo}",
+    "index.ts": "console.log([process.env.FOO, process.env.BAR, process.env.MOO].join('|'));",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("foo|foo bar|foo foo bar moo");
+});
+
+test(".env comments", () => {
+  const dir = tempDirWithFiles("dotenv-comments", {
+    ".env": "#FOZ\nFOO = foo#FAIL\nBAR='bar' #BAZ",
+    "index.ts": "console.log(process.env.FOO, process.env.BAR);",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("foo bar");
+});
+
+test(".env escaped dollar sign", () => {
+  const dir = tempDirWithFiles("dotenv-dollar", {
+    ".env": "FOO=foo\nBAR=\\$FOO",
+    "index.ts": "console.log(process.env.FOO, process.env.BAR);",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("foo $FOO");
+});
+
 test(".env doesnt crash with 159 bytes", () => {
   const dir = tempDirWithFiles("dotenv-159", {
     ".env":
@@ -217,28 +262,59 @@ test(".env doesnt crash with 159 bytes", () => {
   );
 });
 
-test.todo(".env space edgecase (issue #411)", () => {
+test(".env with >768 entries", () => {
+  const dir = tempDirWithFiles("dotenv-many-entries", {
+    ".env": new Array(2000)
+      .fill(null)
+      .map((_, i) => `TEST_VAR${i}=TEST_VAL${i}`)
+      .join("\n"),
+    "index.ts": "console.log(process.env.TEST_VAR47);",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("TEST_VAL47");
+});
+
+test(".env space edgecase (issue #411)", () => {
   const dir = tempDirWithFiles("dotenv-issue-411", {
     ".env": "VARNAME=A B",
-    "index.ts": "console.log('[' + process.env.VARNAME + ']'); ",
+    "index.ts": "console.log('[' + process.env.VARNAME + ']');",
   });
   const { stdout } = bunRun(`${dir}/index.ts`);
   expect(stdout).toBe("[A B]");
 });
 
-test.todo(".env special characters 1 (issue #2823)", () => {
-  const dir = tempDirWithFiles("dotenv-issue-411", {
-    ".env": 'A="a$t"\n',
-    "index.ts": "console.log('[' + process.env.A + ']'); ",
+test(".env special characters 1 (issue #2823)", () => {
+  const dir = tempDirWithFiles("dotenv-issue-2823", {
+    ".env": 'A="a$t"\nC=`c\\$v`',
+    "index.ts": "console.log('[' + process.env.A + ']', '[' + process.env.C + ']');",
   });
   const { stdout } = bunRun(`${dir}/index.ts`);
-  expect(stdout).toBe("[a$t]");
+  expect(stdout).toBe("[a] [c$v]");
 });
 
 test.todo("env escaped quote (issue #2484)", () => {
-  const dir = tempDirWithFiles("dotenv-issue-411", {
+  const dir = tempDirWithFiles("env-issue-2484", {
     "index.ts": "console.log(process.env.VALUE, process.env.VALUE2);",
   });
   const { stdout } = bunRun(`${dir}/index.ts`, { VALUE: `\\"`, VALUE2: `\\\\"` });
   expect(stdout).toBe('\\" \\\\"');
 });
+
+test(".env Windows-style newline (issue #3042)", () => {
+  const dir = tempDirWithFiles("dotenv-issue-3042", {
+    ".env": "FOO=\rBAR='bar\r\rbaz'\r\nMOO=moo\r",
+    "index.ts": "console.log([process.env.FOO, process.env.BAR, process.env.MOO].join('|'));",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("|bar\n\nbaz|moo");
+});
+
+test(".env with zero length strings", () => {
+  const dir = tempDirWithFiles("dotenv-issue-zerolength", {
+    ".env": "FOO=''\n",
+    "index.ts":
+      "function i(a){return a}\nconsole.log([process.env.FOO,i(process.env).FOO,process.env.FOO.length,i(process.env).FOO.length].join('|'));",
+  });
+  const { stdout } = bunRun(`${dir}/index.ts`);
+  expect(stdout).toBe("||0|0");
+});
diff --git a/test/cli/run/require-cache-fixture-b.cjs b/test/cli/run/require-cache-fixture-b.cjs
index 8f8e40ff0..c3f2c8a26 100644
--- a/test/cli/run/require-cache-fixture-b.cjs
+++ b/test/cli/run/require-cache-fixture-b.cjs
@@ -1,3 +1,8 @@
 exports.foo = 123;
 exports.bar = 456;
 exports.baz = 789;
+
+if (require.main === module) {
+  console.error(__filename, module.id);
+  throw new Error("require.main === module");
+}
diff --git a/test/cli/run/require-cache-fixture.cjs b/test/cli/run/require-cache-fixture.cjs
index b04e751ac..838be9ceb 100644
--- a/test/cli/run/require-cache-fixture.cjs
+++ b/test/cli/run/require-cache-fixture.cjs
@@ -3,6 +3,16 @@ const Bun = (globalThis.Bun ??= { gc() {} });
 
 const { resolve } = require("path");
 
+if (require.main !== module) {
+  console.error(__filename, module.id);
+  throw new Error("require.main !== module");
+}
+
+if (process.mainModule !== module) {
+  console.error(__filename, module.id);
+  throw new Error("process.mainModule !== module");
+}
+
 if (__filename !== resolve(module.filename)) {
   console.error(__filename, module.id);
   throw new Error("__filename !== module.id");
diff --git a/test/cli/test/bun-test.test.ts b/test/cli/test/bun-test.test.ts
index 47ea17db3..534c17513 100644
--- a/test/cli/test/bun-test.test.ts
+++ b/test/cli/test/bun-test.test.ts
@@ -192,14 +192,34 @@ describe("bun test", () => {
       });
       expect(stderr).toContain("Invalid timeout");
     });
+    test("timeout can be set to 0ms", () => {
+      const stderr = runTest({
+        args: ["--timeout", "0"],
+        input: `
+          import { test, expect } from "bun:test";
+          import { sleep } from "bun";
+          test("ok", async () => {
+            await expect(Promise.resolve()).resolves.toBeUndefined();
+            await expect(Promise.reject()).rejects.toBeUndefined();
+          });
+          test("timeout", async () => {
+            await expect(sleep(1)).resolves.toBeUndefined();
+          });
+        `,
+      });
+      expect(stderr).toContain("timed out after 0ms");
+    });
     test("timeout can be set to 1ms", () => {
       const stderr = runTest({
         args: ["--timeout", "1"],
         input: `
           import { test, expect } from "bun:test";
           import { sleep } from "bun";
+          test("ok", async () => {
+            await expect(sleep(1)).resolves.toBeUndefined();
+          });
           test("timeout", async () => {
-            await sleep(2);
+            await expect(sleep(2)).resolves.toBeUndefined();
           });
         `,
       });