diff --git a/.buildkite/ci.mjs b/.buildkite/ci.mjs
old mode 100644
new mode 100755
index c9c005198790be..3de0aa57b61a6b
--- a/.buildkite/ci.mjs
+++ b/.buildkite/ci.mjs
@@ -8,10 +8,13 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
+  getBootstrapVersion,
+  getBuildNumber,
   getCanaryRevision,
   getChangedFiles,
   getCommit,
   getCommitMessage,
+  getEnv,
   getLastSuccessfulBuild,
   getMainBranch,
   getTargetBranch,
@@ -21,103 +24,162 @@ import {
   isMergeQueue,
   printEnvironment,
   spawnSafe,
-  startGroup,
+  toYaml,
+  uploadArtifact,
 } from "../scripts/utils.mjs";
 
-function toYaml(obj, indent = 0) {
-  const spaces = " ".repeat(indent);
-  let result = "";
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === undefined) {
-      continue;
-    }
-
-    if (value === null) {
-      result += `${spaces}${key}: null\n`;
-      continue;
-    }
+/**
+ * @typedef PipelineOptions
+ * @property {string} [buildId]
+ * @property {boolean} [buildImages]
+ * @property {boolean} [publishImages]
+ * @property {boolean} [skipTests]
+ */
 
-    if (Array.isArray(value)) {
-      result += `${spaces}${key}:\n`;
-      value.forEach(item => {
-        if (typeof item === "object" && item !== null) {
-          result += `${spaces}- \n${toYaml(item, indent + 2)
-            .split("\n")
-            .map(line => `${spaces}  ${line}`)
-            .join("\n")}\n`;
-        } else {
-          result += `${spaces}- ${item}\n`;
-        }
-      });
-      continue;
-    }
+/**
+ * @param {PipelineOptions} options
+ */
+function getPipeline(options) {
+  const { buildId, buildImages, publishImages, skipTests } = options;
 
-    if (typeof value === "object") {
-      result += `${spaces}${key}:\n${toYaml(value, indent + 2)}`;
-      continue;
-    }
+  /**
+   * Helpers
+   */
 
-    if (
-      typeof value === "string" &&
-      (value.includes(":") || value.includes("#") || value.includes("'") || value.includes('"') || value.includes("\n"))
-    ) {
-      result += `${spaces}${key}: "${value.replace(/"/g, '\\"')}"\n`;
-      continue;
+  /**
+   * @param {string} text
+   * @returns {string}
+   * @link https://github.com/buildkite/emojis#emoji-reference
+   */
+  const getEmoji = string => {
+    if (string === "amazonlinux") {
+      return ":aws:";
     }
+    return `:${string}:`;
+  };
 
-    result += `${spaces}${key}: ${value}\n`;
-  }
-
-  return result;
-}
-
-function getPipeline(buildId) {
   /**
-   * Helpers
+   * @typedef {"linux" | "darwin" | "windows"} Os
+   * @typedef {"aarch64" | "x64"} Arch
+   * @typedef {"musl"} Abi
    */
 
-  const getKey = platform => {
-    const { os, arch, abi, baseline } = platform;
+  /**
+   * @typedef Target
+   * @property {Os} os
+   * @property {Arch} arch
+   * @property {Abi} [abi]
+   * @property {boolean} [baseline]
+   */
 
+  /**
+   * @param {Target} target
+   * @returns {string}
+   */
+  const getTargetKey = target => {
+    const { os, arch, abi, baseline } = target;
+    let key = `${os}-${arch}`;
     if (abi) {
-      if (baseline) {
-        return `${os}-${arch}-${abi}-baseline`;
-      }
-      return `${os}-${arch}-${abi}`;
+      key += `-${abi}`;
     }
     if (baseline) {
-      return `${os}-${arch}-baseline`;
+      key += "-baseline";
     }
-
-    return `${os}-${arch}`;
+    return key;
   };
 
-  const getLabel = platform => {
-    const { os, arch, abi, baseline, release } = platform;
-    let label = release ? `:${os}: ${release} ${arch}` : `:${os}: ${arch}`;
+  /**
+   * @param {Target} target
+   * @returns {string}
+   */
+  const getTargetLabel = target => {
+    const { os, arch, abi, baseline } = target;
+    let label = `${getEmoji(os)} ${arch}`;
     if (abi) {
       label += `-${abi}`;
     }
     if (baseline) {
-      label += `-baseline`;
+      label += "-baseline";
     }
     return label;
   };
 
-  // https://buildkite.com/docs/pipelines/command-step#retry-attributes
-  const getRetry = (limit = 3) => {
+  /**
+   * @typedef Platform
+   * @property {Os} os
+   * @property {Arch} arch
+   * @property {Abi} [abi]
+   * @property {boolean} [baseline]
+   * @property {string} [distro]
+   * @property {string} release
+   */
+
+  /**
+   * @param {Platform} platform
+   * @returns {string}
+   */
+  const getPlatformKey = platform => {
+    const { os, arch, abi, baseline, distro, release } = platform;
+    const target = getTargetKey({ os, arch, abi, baseline });
+    if (distro) {
+      return `${target}-${distro}-${release.replace(/\./g, "")}`;
+    }
+    return `${target}-${release.replace(/\./g, "")}`;
+  };
+
+  /**
+   * @param {Platform} platform
+   * @returns {string}
+   */
+  const getPlatformLabel = platform => {
+    const { os, arch, baseline, distro, release } = platform;
+    let label = `${getEmoji(distro || os)} ${release} ${arch}`;
+    if (baseline) {
+      label += "-baseline";
+    }
+    return label;
+  };
+
+  /**
+   * @param {Platform} platform
+   * @returns {string}
+   */
+  const getImageKey = platform => {
+    const { os, arch, distro, release } = platform;
+    if (distro) {
+      return `${os}-${arch}-${distro}-${release.replace(/\./g, "")}`;
+    }
+    return `${os}-${arch}-${release.replace(/\./g, "")}`;
+  };
+
+  /**
+   * @param {Platform} platform
+   * @returns {string}
+   */
+  const getImageLabel = platform => {
+    const { os, arch, distro, release } = platform;
+    return `${getEmoji(distro || os)} ${release} ${arch}`;
+  };
+
+  /**
+   * @param {number} [limit]
+   * @link https://buildkite.com/docs/pipelines/command-step#retry-attributes
+   */
+  const getRetry = (limit = 0) => {
     return {
       automatic: [
-        { exit_status: 1, limit: 1 },
-        { exit_status: -1, limit },
-        { exit_status: 255, limit },
-        { signal_reason: "agent_stop", limit },
+        { exit_status: 1, limit },
+        { exit_status: -1, limit: 3 },
+        { exit_status: 255, limit: 3 },
+        { signal_reason: "agent_stop", limit: 3 },
       ],
     };
   };
 
-  // https://buildkite.com/docs/pipelines/managing-priorities
+  /**
+   * @returns {number}
+   * @link https://buildkite.com/docs/pipelines/managing-priorities
+   */
   const getPriority = () => {
     if (isFork()) {
       return -1;
@@ -132,156 +194,333 @@ function getPipeline(buildId) {
   };
 
   /**
-   * Steps
+   * @param {Target} target
+   * @returns {Record<string, string | undefined>}
    */
+  const getBuildEnv = target => {
+    const { baseline, abi } = target;
+    return {
+      ENABLE_BASELINE: baseline ? "ON" : "OFF",
+      ABI: abi === "musl" ? "musl" : undefined,
+    };
+  };
 
-  const getBuildVendorStep = platform => {
-    const { os, arch, abi, baseline } = platform;
+  /**
+   * @param {Target} target
+   * @returns {string}
+   */
+  const getBuildToolchain = target => {
+    const { os, arch, abi, baseline } = target;
+    let key = `${os}-${arch}`;
+    if (abi) {
+      key += `-${abi}`;
+    }
+    if (baseline) {
+      key += "-baseline";
+    }
+    return key;
+  };
+
+  /**
+   * Agents
+   */
+
+  /**
+   * @typedef {Record<string, string | undefined>} Agent
+   */
+
+  /**
+   * @param {Platform} platform
+   * @returns {boolean}
+   */
+  const isUsingNewAgent = platform => {
+    const { os } = platform;
+    if (os === "linux") {
+      return true;
+    }
+    return false;
+  };
 
+  /**
+   * @param {"v1" | "v2"} version
+   * @param {Platform} platform
+   * @param {string} [instanceType]
+   * @returns {Agent}
+   */
+  const getEmphemeralAgent = (version, platform, instanceType) => {
+    const { os, arch, abi, distro, release } = platform;
+    if (version === "v1") {
+      return {
+        robobun: true,
+        os,
+        arch,
+        distro,
+        release,
+      };
+    }
+    let image;
+    if (distro) {
+      image = `${os}-${arch}-${distro}-${release}`;
+    } else {
+      image = `${os}-${arch}-${release}`;
+    }
+    if (buildImages && !publishImages) {
+      image += `-build-${getBuildNumber()}`;
+    } else {
+      image += `-v${getBootstrapVersion()}`;
+    }
     return {
-      key: `${getKey(platform)}-build-vendor`,
-      label: `build-vendor`,
-      agents: {
+      robobun: true,
+      robobun2: true,
+      os,
+      arch,
+      abi,
+      distro,
+      release,
+      "image-name": image,
+      "instance-type": instanceType,
+    };
+  };
+
+  /**
+   * @param {Target} target
+   * @returns {Agent}
+   */
+  const getBuildAgent = target => {
+    const { os, arch, abi } = target;
+    if (isUsingNewAgent(target)) {
+      const instanceType = arch === "aarch64" ? "c8g.8xlarge" : "c7i.8xlarge";
+      return getEmphemeralAgent("v2", target, instanceType);
+    }
+    return {
+      queue: `build-${os}`,
+      os,
+      arch,
+      abi,
+    };
+  };
+
+  /**
+   * @param {Target} target
+   * @returns {Agent}
+   */
+  const getZigAgent = target => {
+    const { abi, arch } = target;
+    // if (abi === "musl") {
+    //   const instanceType = arch === "aarch64" ? "c8g.large" : "c7i.large";
+    //   return getEmphemeralAgent("v2", target, instanceType);
+    // }
+    return {
+      queue: "build-zig",
+    };
+  };
+
+  /**
+   * @param {Platform} platform
+   * @returns {Agent}
+   */
+  const getTestAgent = platform => {
+    const { os, arch, release } = platform;
+    if (isUsingNewAgent(platform)) {
+      const instanceType = arch === "aarch64" ? "t4g.large" : "t3.large";
+      return getEmphemeralAgent("v2", platform, instanceType);
+    }
+    if (os === "darwin") {
+      return {
         os,
         arch,
-        abi,
-        queue: abi ? `build-${os}-${abi}` : `build-${os}`,
+        release,
+        queue: "test-darwin",
+      };
+    }
+    return getEmphemeralAgent("v1", platform);
+  };
+
+  /**
+   * Steps
+   */
+
+  /**
+   * @typedef Step
+   * @property {string} key
+   * @property {string} [label]
+   * @property {Record<string, string | undefined>} [agents]
+   * @property {Record<string, string | undefined>} [env]
+   * @property {string} command
+   * @property {string[]} [depends_on]
+   * @property {Record<string, string | undefined>} [retry]
+   * @property {boolean} [cancel_on_build_failing]
+   * @property {boolean} [soft_fail]
+   * @property {number} [parallelism]
+   * @property {number} [concurrency]
+   * @property {string} [concurrency_group]
+   * @property {number} [priority]
+   * @property {number} [timeout_in_minutes]
+   * @link https://buildkite.com/docs/pipelines/command-step
+   */
+
+  /**
+   * @param {Platform} platform
+   * @param {string} [step]
+   * @returns {string[]}
+   */
+  const getDependsOn = (platform, step) => {
+    if (imagePlatforms.has(getImageKey(platform))) {
+      const key = `${getImageKey(platform)}-build-image`;
+      if (key !== step) {
+        return [key];
+      }
+    }
+    return [];
+  };
+
+  /**
+   * @param {Platform} platform
+   * @returns {Step}
+   */
+  const getBuildImageStep = platform => {
+    const { os, arch, distro, release } = platform;
+    const action = publishImages ? "publish-image" : "create-image";
+    return {
+      key: `${getImageKey(platform)}-build-image`,
+      label: `${getImageLabel(platform)} - build-image`,
+      agents: {
+        queue: "build-image",
       },
-      retry: getRetry(),
-      cancel_on_build_failing: isMergeQueue(),
       env: {
-        ENABLE_BASELINE: baseline ? "ON" : "OFF",
+        DEBUG: "1",
       },
+      retry: getRetry(),
+      command: `node ./scripts/machine.mjs ${action} --ci --cloud=aws --os=${os} --arch=${arch} --distro=${distro} --distro-version=${release}`,
+    };
+  };
+
+  /**
+   * @param {Platform} platform
+   * @returns {Step}
+   */
+  const getBuildVendorStep = platform => {
+    return {
+      key: `${getTargetKey(platform)}-build-vendor`,
+      label: `${getTargetLabel(platform)} - build-vendor`,
+      depends_on: getDependsOn(platform),
+      agents: getBuildAgent(platform),
+      retry: getRetry(),
+      cancel_on_build_failing: isMergeQueue(),
+      env: getBuildEnv(platform),
       command: "bun run build:ci --target dependencies",
     };
   };
 
+  /**
+   * @param {Platform} platform
+   * @returns {Step}
+   */
   const getBuildCppStep = platform => {
-    const { os, arch, abi, baseline } = platform;
-
     return {
-      key: `${getKey(platform)}-build-cpp`,
-      label: `build-cpp`,
-      agents: {
-        os,
-        arch,
-        abi,
-        queue: abi ? `build-${os}-${abi}` : `build-${os}`,
-      },
+      key: `${getTargetKey(platform)}-build-cpp`,
+      label: `${getTargetLabel(platform)} - build-cpp`,
+      depends_on: getDependsOn(platform),
+      agents: getBuildAgent(platform),
       retry: getRetry(),
       cancel_on_build_failing: isMergeQueue(),
       env: {
         BUN_CPP_ONLY: "ON",
-        ENABLE_BASELINE: baseline ? "ON" : "OFF",
+        ...getBuildEnv(platform),
       },
       command: "bun run build:ci --target bun",
     };
   };
 
+  /**
+   * @param {Platform} platform
+   * @returns {Step}
+   */
   const getBuildZigStep = platform => {
-    const { os, arch, abi, baseline } = platform;
-    const toolchain = getKey(platform);
-
+    const toolchain = getBuildToolchain(platform);
     return {
-      key: `${getKey(platform)}-build-zig`,
-      label: `build-zig`,
-      agents: {
-        queue: "build-zig",
-      },
-      retry: getRetry(),
+      key: `${getTargetKey(platform)}-build-zig`,
+      label: `${getTargetLabel(platform)} - build-zig`,
+      depends_on: getDependsOn(platform),
+      agents: getZigAgent(platform),
+      retry: getRetry(1), // FIXME: Sometimes zig build hangs, so we need to retry once
       cancel_on_build_failing: isMergeQueue(),
-      env: {
-        ENABLE_BASELINE: baseline ? "ON" : "OFF",
-      },
+      env: getBuildEnv(platform),
       command: `bun run build:ci --target bun-zig --toolchain ${toolchain}`,
     };
   };
 
+  /**
+   * @param {Platform} platform
+   * @returns {Step}
+   */
   const getBuildBunStep = platform => {
-    const { os, arch, abi, baseline } = platform;
-
     return {
-      key: `${getKey(platform)}-build-bun`,
-      label: `build-bun`,
+      key: `${getTargetKey(platform)}-build-bun`,
+      label: `${getTargetLabel(platform)} - build-bun`,
       depends_on: [
-        `${getKey(platform)}-build-vendor`,
-        `${getKey(platform)}-build-cpp`,
-        `${getKey(platform)}-build-zig`,
+        `${getTargetKey(platform)}-build-vendor`,
+        `${getTargetKey(platform)}-build-cpp`,
+        `${getTargetKey(platform)}-build-zig`,
       ],
-      agents: {
-        os,
-        arch,
-        abi,
-        queue: `build-${os}`,
-      },
+      agents: getBuildAgent(platform),
       retry: getRetry(),
       cancel_on_build_failing: isMergeQueue(),
       env: {
         BUN_LINK_ONLY: "ON",
-        ENABLE_BASELINE: baseline ? "ON" : "OFF",
+        ...getBuildEnv(platform),
       },
       command: "bun run build:ci --target bun",
     };
   };
 
+  /**
+   * @param {Platform} platform
+   * @returns {Step}
+   */
   const getTestBunStep = platform => {
-    const { os, arch, abi, distro, release } = platform;
-
-    let name;
-    if (os === "darwin" || os === "windows") {
-      name = getLabel({ ...platform, release });
-    } else {
-      name = getLabel({ ...platform, os: distro, release });
-    }
-
-    let agents;
-    if (os === "darwin") {
-      agents = { os, arch, abi, queue: `test-darwin` };
-    } else if (os === "windows") {
-      agents = { os, arch, abi, robobun: true };
-    } else {
-      agents = { os, arch, abi, distro, release, robobun: true };
-    }
-
+    const { os } = platform;
     let command;
     if (os === "windows") {
-      command = `node .\\scripts\\runner.node.mjs --step ${getKey(platform)}-build-bun`;
+      command = `node .\\scripts\\runner.node.mjs --step ${getTargetKey(platform)}-build-bun`;
     } else {
-      command = `./scripts/runner.node.mjs --step ${getKey(platform)}-build-bun`;
+      command = `./scripts/runner.node.mjs --step ${getTargetKey(platform)}-build-bun`;
     }
-
     let parallelism;
     if (os === "darwin") {
       parallelism = 2;
     } else {
       parallelism = 10;
     }
-
-    let depends;
     let env;
+    let depends = [];
     if (buildId) {
       env = {
         BUILDKITE_ARTIFACT_BUILD_ID: buildId,
       };
     } else {
-      depends = [`${getKey(platform)}-build-bun`];
+      depends = [`${getTargetKey(platform)}-build-bun`];
     }
-
     let retry;
     if (os !== "windows") {
       // When the runner fails on Windows, Buildkite only detects an exit code of 1.
       // Because of this, we don't know if the run was fatal, or soft-failed.
-      retry = getRetry();
+      retry = getRetry(1);
+    }
+    let soft_fail;
+    if (isMainBranch()) {
+      soft_fail = true;
+    } else {
+      soft_fail = [{ exit_status: 2 }];
     }
-
     return {
-      key: `${getKey(platform)}-${distro}-${release.replace(/\./g, "")}-test-bun`,
-      label: `${name} - test-bun`,
-      depends_on: depends,
-      agents,
+      key: `${getPlatformKey(platform)}-test-bun`,
+      label: `${getPlatformLabel(platform)} - test-bun`,
+      depends_on: [...depends, ...getDependsOn(platform)],
+      agents: getTestAgent(platform),
       retry,
       cancel_on_build_failing: isMergeQueue(),
-      soft_fail: isMainBranch(),
+      soft_fail,
       parallelism,
       command,
       env,
@@ -292,66 +531,136 @@ function getPipeline(buildId) {
    * Config
    */
 
+  /**
+   * @type {Platform[]}
+   */
   const buildPlatforms = [
-    { os: "darwin", arch: "aarch64" },
-    { os: "darwin", arch: "x64" },
-    { os: "linux", arch: "aarch64" },
-    // { os: "linux", arch: "aarch64", abi: "musl" }, // TODO:
-    { os: "linux", arch: "x64" },
-    { os: "linux", arch: "x64", baseline: true },
-    // { os: "linux", arch: "x64", abi: "musl" }, // TODO:
-    { os: "windows", arch: "x64" },
-    { os: "windows", arch: "x64", baseline: true },
+    { os: "darwin", arch: "aarch64", release: "14" },
+    { os: "darwin", arch: "x64", release: "14" },
+    { os: "linux", arch: "aarch64", distro: "debian", release: "11" },
+    { os: "linux", arch: "x64", distro: "debian", release: "11" },
+    { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "11" },
+    { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.20" },
+    { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.20" },
+    { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.20" },
+    { os: "windows", arch: "x64", release: "2019" },
+    { os: "windows", arch: "x64", baseline: true, release: "2019" },
   ];
 
+  /**
+   * @type {Platform[]}
+   */
   const testPlatforms = [
-    { os: "darwin", arch: "aarch64", distro: "sonoma", release: "14" },
-    { os: "darwin", arch: "aarch64", distro: "ventura", release: "13" },
-    { os: "darwin", arch: "x64", distro: "sonoma", release: "14" },
-    { os: "darwin", arch: "x64", distro: "ventura", release: "13" },
+    { os: "darwin", arch: "aarch64", release: "14" },
+    { os: "darwin", arch: "aarch64", release: "13" },
+    { os: "darwin", arch: "x64", release: "14" },
+    { os: "darwin", arch: "x64", release: "13" },
     { os: "linux", arch: "aarch64", distro: "debian", release: "12" },
+    { os: "linux", arch: "aarch64", distro: "debian", release: "11" },
+    { os: "linux", arch: "aarch64", distro: "debian", release: "10" },
+    { os: "linux", arch: "x64", distro: "debian", release: "12" },
+    { os: "linux", arch: "x64", distro: "debian", release: "11" },
+    { os: "linux", arch: "x64", distro: "debian", release: "10" },
+    { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "12" },
+    { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "11" },
+    { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "10" },
+    // { os: "linux", arch: "aarch64", distro: "ubuntu", release: "24.04" },
     { os: "linux", arch: "aarch64", distro: "ubuntu", release: "22.04" },
     { os: "linux", arch: "aarch64", distro: "ubuntu", release: "20.04" },
-    // { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "edge" }, // TODO:
-    { os: "linux", arch: "x64", distro: "debian", release: "12" },
+    // { os: "linux", arch: "x64", distro: "ubuntu", release: "24.04" },
     { os: "linux", arch: "x64", distro: "ubuntu", release: "22.04" },
     { os: "linux", arch: "x64", distro: "ubuntu", release: "20.04" },
-    { os: "linux", arch: "x64", distro: "debian", release: "12", baseline: true },
-    { os: "linux", arch: "x64", distro: "ubuntu", release: "22.04", baseline: true },
-    { os: "linux", arch: "x64", distro: "ubuntu", release: "20.04", baseline: true },
-    // { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "edge" }, // TODO:
-    { os: "windows", arch: "x64", distro: "server", release: "2019" },
-    { os: "windows", arch: "x64", distro: "server", release: "2019", baseline: true },
+    // { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "24.04" },
+    { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "22.04" },
+    { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "20.04" },
+    { os: "linux", arch: "aarch64", distro: "amazonlinux", release: "2023" },
+    // { os: "linux", arch: "aarch64", distro: "amazonlinux", release: "2" },
+    { os: "linux", arch: "x64", distro: "amazonlinux", release: "2023" },
+    // { os: "linux", arch: "x64", distro: "amazonlinux", release: "2" },
+    { os: "linux", arch: "x64", baseline: true, distro: "amazonlinux", release: "2023" },
+    // { os: "linux", arch: "x64", baseline: true, distro: "amazonlinux", release: "2" },
+    { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.20" },
+    // { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.17" },
+    { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.20" },
+    // { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.17" },
+    { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.20" },
+    // { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.17" },
+    { os: "windows", arch: "x64", release: "2019" },
+    { os: "windows", arch: "x64", baseline: true, release: "2019" },
   ];
 
+  const imagePlatforms = new Map(
+    [...buildPlatforms, ...testPlatforms]
+      .filter(platform => buildImages && isUsingNewAgent(platform))
+      .map(platform => [getImageKey(platform), platform]),
+  );
+
+  /**
+   * @type {Step[]}
+   */
+  const steps = [];
+
+  if (imagePlatforms.size) {
+    steps.push({
+      group: ":docker:",
+      steps: [...imagePlatforms.values()].map(platform => getBuildImageStep(platform)),
+    });
+  }
+
+  for (const platform of buildPlatforms) {
+    const { os, arch, abi, baseline } = platform;
+
+    /** @type {Step[]} */
+    const platformSteps = [];
+
+    if (buildImages || !buildId) {
+      platformSteps.push(
+        getBuildVendorStep(platform),
+        getBuildCppStep(platform),
+        getBuildZigStep(platform),
+        getBuildBunStep(platform),
+      );
+    }
+
+    if (!skipTests) {
+      platformSteps.push(
+        ...testPlatforms
+          .filter(
+            testPlatform =>
+              testPlatform.os === os &&
+              testPlatform.arch === arch &&
+              testPlatform.abi === abi &&
+              testPlatform.baseline === baseline,
+          )
+          .map(testPlatform => getTestBunStep(testPlatform)),
+      );
+    }
+
+    if (!platformSteps.length) {
+      continue;
+    }
+
+    steps.push({
+      key: getTargetKey(platform),
+      group: getTargetLabel(platform),
+      steps: platformSteps,
+    });
+  }
+
+  if (isMainBranch() && !isFork()) {
+    steps.push({
+      label: ":github:",
+      agents: {
+        queue: "test-darwin",
+      },
+      depends_on: buildPlatforms.map(platform => `${getTargetKey(platform)}-build-bun`),
+      command: ".buildkite/scripts/upload-release.sh",
+    });
+  }
+
   return {
     priority: getPriority(),
-    steps: [
-      ...buildPlatforms.map(platform => {
-        const { os, arch, baseline } = platform;
-
-        let steps = [
-          ...testPlatforms
-            .filter(platform => platform.os === os && platform.arch === arch && baseline === platform.baseline)
-            .map(platform => getTestBunStep(platform)),
-        ];
-
-        if (!buildId) {
-          steps.unshift(
-            getBuildVendorStep(platform),
-            getBuildCppStep(platform),
-            getBuildZigStep(platform),
-            getBuildBunStep(platform),
-          );
-        }
-
-        return {
-          key: getKey(platform),
-          group: getLabel(platform),
-          steps,
-        };
-      }),
-    ],
+    steps,
   };
 }
 
@@ -369,26 +678,51 @@ async function main() {
     console.log(" - No build found");
   }
 
-  console.log("Checking changed files...");
-  const baseRef = getCommit();
-  console.log(" - Base Ref:", baseRef);
-  const headRef = lastBuild?.commit_id || getTargetBranch() || getMainBranch();
-  console.log(" - Head Ref:", headRef);
-
-  const changedFiles = await getChangedFiles(undefined, baseRef, headRef);
-  if (changedFiles) {
-    if (changedFiles.length) {
-      changedFiles.forEach(filename => console.log(` - ${filename}`));
-    } else {
-      console.log(" - No changed files");
+  let changedFiles;
+  // FIXME: Fix various bugs when calculating changed files
+  // false -> !isFork() && !isMainBranch()
+  if (false) {
+    console.log("Checking changed files...");
+    const baseRef = lastBuild?.commit_id || getTargetBranch() || getMainBranch();
+    console.log(" - Base Ref:", baseRef);
+    const headRef = getCommit();
+    console.log(" - Head Ref:", headRef);
+
+    changedFiles = await getChangedFiles(undefined, baseRef, headRef);
+    if (changedFiles) {
+      if (changedFiles.length) {
+        changedFiles.forEach(filename => console.log(` - ${filename}`));
+      } else {
+        console.log(" - No changed files");
+      }
     }
   }
 
   const isDocumentationFile = filename => /^(\.vscode|\.github|bench|docs|examples)|\.(md)$/i.test(filename);
   const isTestFile = filename => /^test/i.test(filename) || /runner\.node\.mjs$/i.test(filename);
 
-  console.log("Checking if CI should be skipped...");
+  console.log("Checking if CI should be forced...");
+  let forceBuild;
+  let ciFileChanged;
   {
+    const message = getCommitMessage();
+    const match = /\[(force ci|ci force|ci force build)\]/i.exec(message);
+    if (match) {
+      const [, reason] = match;
+      console.log(" - Yes, because commit message contains:", reason);
+      forceBuild = true;
+    }
+    for (const coref of [".buildkite/ci.mjs", "scripts/utils.mjs", "scripts/bootstrap.sh", "scripts/machine.mjs"]) {
+      if (changedFiles && changedFiles.includes(coref)) {
+        console.log(" - Yes, because the list of changed files contains:", coref);
+        forceBuild = true;
+        ciFileChanged = true;
+      }
+    }
+  }
+
+  console.log("Checking if CI should be skipped...");
+  if (!forceBuild) {
     const message = getCommitMessage();
     const match = /\[(skip ci|no ci|ci skip|ci no)\]/i.exec(message);
     if (match) {
@@ -396,15 +730,49 @@ async function main() {
       console.log(" - Yes, because commit message contains:", reason);
       return;
     }
+    if (changedFiles && changedFiles.every(filename => isDocumentationFile(filename))) {
+      console.log(" - Yes, because all changed files are documentation");
+      return;
+    }
   }
-  if (changedFiles && changedFiles.every(filename => isDocumentationFile(filename))) {
-    console.log(" - Yes, because all changed files are documentation");
-    return;
+
+  console.log("Checking if CI should re-build images...");
+  let buildImages;
+  {
+    const message = getCommitMessage();
+    const match = /\[(build images?|images? build)\]/i.exec(message);
+    if (match) {
+      const [, reason] = match;
+      console.log(" - Yes, because commit message contains:", reason);
+      buildImages = true;
+    }
+    if (ciFileChanged) {
+      console.log(" - Yes, because a core CI file changed");
+      buildImages = true;
+    }
+  }
+
+  console.log("Checking if CI should publish images...");
+  let publishImages;
+  {
+    const message = getCommitMessage();
+    const match = /\[(publish images?|images? publish)\]/i.exec(message);
+    if (match) {
+      const [, reason] = match;
+      console.log(" - Yes, because commit message contains:", reason);
+      publishImages = true;
+      buildImages = true;
+    }
+    if (ciFileChanged && isMainBranch()) {
+      console.log(" - Yes, because a core CI file changed and this is main branch");
+      publishImages = true;
+      buildImages = true;
+    }
   }
 
   console.log("Checking if build should be skipped...");
   let skipBuild;
-  {
+  if (!forceBuild) {
     const message = getCommitMessage();
     const match = /\[(only tests?|tests? only|skip build|no build|build skip|build no)\]/i.exec(message);
     if (match) {
@@ -412,15 +780,33 @@ async function main() {
       console.log(" - Yes, because commit message contains:", reason);
       skipBuild = true;
     }
+    if (changedFiles && changedFiles.every(filename => isTestFile(filename) || isDocumentationFile(filename))) {
+      console.log(" - Yes, because all changed files are tests or documentation");
+      skipBuild = true;
+    }
   }
-  if (changedFiles && changedFiles.every(filename => isTestFile(filename) || isDocumentationFile(filename))) {
-    console.log(" - Yes, because all changed files are tests or documentation");
-    skipBuild = true;
+
+  console.log("Checking if tests should be skipped...");
+  let skipTests;
+  {
+    const message = getCommitMessage();
+    const match = /\[(skip tests?|tests? skip|no tests?|tests? no)\]/i.exec(message);
+    if (match) {
+      console.log(" - Yes, because commit message contains:", match[1]);
+      skipTests = true;
+    }
+    if (isMainBranch()) {
+      console.log(" - Yes, because we're on main branch");
+      skipTests = true;
+    }
   }
 
   console.log("Checking if build is a named release...");
   let buildRelease;
-  {
+  if (/^(1|true|on|yes)$/i.test(getEnv("RELEASE", false))) {
+    console.log(" - Yes, because RELEASE environment variable is set");
+    buildRelease = true;
+  } else {
     const message = getCommitMessage();
     const match = /\[(release|release build|build release)\]/i.exec(message);
     if (match) {
@@ -431,7 +817,13 @@ async function main() {
   }
 
   console.log("Generating pipeline...");
-  const pipeline = getPipeline(lastBuild && skipBuild ? lastBuild.id : undefined);
+  const pipeline = getPipeline({
+    buildId: lastBuild && skipBuild && !forceBuild ? lastBuild.id : undefined,
+    buildImages,
+    publishImages,
+    skipTests,
+  });
+
   const content = toYaml(pipeline);
   const contentPath = join(process.cwd(), ".buildkite", "ci.yml");
   writeFileSync(contentPath, content);
@@ -439,14 +831,17 @@ async function main() {
   console.log("Generated pipeline:");
   console.log(" - Path:", contentPath);
   console.log(" - Size:", (content.length / 1024).toFixed(), "KB");
+  if (isBuildkite) {
+    await uploadArtifact(contentPath);
+  }
 
   if (isBuildkite) {
     console.log("Setting canary revision...");
     const canaryRevision = buildRelease ? 0 : await getCanaryRevision();
-    await spawnSafe(["buildkite-agent", "meta-data", "set", "canary", `${canaryRevision}`]);
+    await spawnSafe(["buildkite-agent", "meta-data", "set", "canary", `${canaryRevision}`], { stdio: "inherit" });
 
     console.log("Uploading pipeline...");
-    await spawnSafe(["buildkite-agent", "pipeline", "upload", contentPath]);
+    await spawnSafe(["buildkite-agent", "pipeline", "upload", contentPath], { stdio: "inherit" });
   }
 }
 
diff --git a/.buildkite/scripts/upload-release.sh b/.buildkite/scripts/upload-release.sh
index 83d70d5730dca3..b684dfb4a3d958 100755
--- a/.buildkite/scripts/upload-release.sh
+++ b/.buildkite/scripts/upload-release.sh
@@ -164,7 +164,9 @@ function upload_s3_file() {
 
 function send_bench_webhook() {
   if [ -z "$BENCHMARK_URL" ]; then
-    return 1
+    echo "error: \$BENCHMARK_URL is not set"
+    # exit 1 # TODO: this isn't live yet
+    return
   fi
 
   local tag="$1"
@@ -200,6 +202,12 @@ function create_release() {
     bun-linux-x64-profile.zip
     bun-linux-x64-baseline.zip
     bun-linux-x64-baseline-profile.zip
+    bun-linux-aarch64-musl.zip
+    bun-linux-aarch64-musl-profile.zip
+    bun-linux-x64-musl.zip
+    bun-linux-x64-musl-profile.zip
+    bun-linux-x64-musl-baseline.zip
+    bun-linux-x64-musl-baseline-profile.zip
     bun-windows-x64.zip
     bun-windows-x64-profile.zip
     bun-windows-x64-baseline.zip
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9feff2712177b1..0bf6e5cf591e00 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -11,7 +11,7 @@ Bun currently requires `glibc >=2.32` in development which means if you're on Ub
 
 Using your system's package manager, install Bun's dependencies:
 
-{% codetabs %}
+{% codetabs group="os" %}
 
 ```bash#macOS (Homebrew)
 $ brew install automake ccache cmake coreutils gnu-sed go icu4c libiconv libtool ninja pkg-config rust ruby
@@ -60,7 +60,7 @@ $ brew install bun
 
 Bun requires LLVM 16 (`clang` is part of LLVM). This version requirement is to match WebKit (precompiled), as mismatching versions will cause memory allocation failures at runtime. In most cases, you can install LLVM through your system package manager:
 
-{% codetabs %}
+{% codetabs group="os" %}
 
 ```bash#macOS (Homebrew)
 $ brew install llvm@18
@@ -97,7 +97,7 @@ $ which clang-16
 
 If not, run this to manually add it:
 
-{% codetabs %}
+{% codetabs group="os" %}
 
 ```bash#macOS (Homebrew)
 # use fish_add_path if you're using fish
@@ -285,7 +285,7 @@ If you see this error when compiling, run:
 $ xcode-select --install
 ```
 
-## Cannot find `libatomic.a`
+### Cannot find `libatomic.a`
 
 Bun defaults to linking `libatomic` statically, as not all systems have it. If you are building on a distro that does not have a static libatomic available, you can run the following command to enable dynamic linking:
 
@@ -295,7 +295,7 @@ $ bun run build -DUSE_STATIC_LIBATOMIC=OFF
 
 The built version of Bun may not work on other systems if compiled this way.
 
-## ccache conflicts with building TinyCC on macOS
+### ccache conflicts with building TinyCC on macOS
 
 If you run into issues with `ccache` when building TinyCC, try reinstalling ccache
 
@@ -303,3 +303,9 @@ If you run into issues with `ccache` when building TinyCC, try reinstalling ccac
 brew uninstall ccache
 brew install ccache
 ```
+
+## Using bun-debug
+
+- Disable logging: `BUN_DEBUG_QUIET_LOGS=1 bun-debug ...` (to disable all debug logging)
+- Enable logging for a specific zig scope: `BUN_DEBUG_EventLoop=1 bun-debug ...` (to allow `std.log.scoped(.EventLoop)`)
+- Bun transpiles every file it runs, to see the actual executed source in a debug build find it in `/tmp/bun-debug-src/...path/to/file`, for example the transpiled version of `/home/bun/index.ts` would be in `/tmp/bun-debug-src/home/bun/index.ts`
diff --git a/LATEST b/LATEST
index 9b51125a6c52d3..474ad5be60e054 100644
--- a/LATEST
+++ b/LATEST
@@ -1 +1 @@
-1.1.34
\ No newline at end of file
+1.1.36
\ No newline at end of file
diff --git a/ci/linux/Dockerfile b/ci/linux/Dockerfile
new file mode 100644
index 00000000000000..3b46e73f6ccdbd
--- /dev/null
+++ b/ci/linux/Dockerfile
@@ -0,0 +1,18 @@
+ARG IMAGE=debian:11
+FROM $IMAGE
+COPY ./scripts/bootstrap.sh /tmp/bootstrap.sh
+ENV CI=true
+RUN sh /tmp/bootstrap.sh && rm -rf /tmp/*
+WORKDIR /workspace/bun
+COPY bunfig.toml bunfig.toml
+COPY package.json package.json
+COPY CMakeLists.txt CMakeLists.txt
+COPY cmake/ cmake/
+COPY scripts/ scripts/
+COPY patches/ patches/
+COPY *.zig ./
+COPY src/ src/
+COPY packages/ packages/
+COPY test/ test/
+RUN bun i
+RUN bun run build:ci
diff --git a/ci/linux/scripts/set-hostname.sh b/ci/linux/scripts/set-hostname.sh
new file mode 100644
index 00000000000000..e529f74ce01976
--- /dev/null
+++ b/ci/linux/scripts/set-hostname.sh
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+# This script sets the hostname of the current machine.
+
+execute() {
+  echo "$ $@" >&2
+  if ! "$@"; then
+    echo "Command failed: $@" >&2
+    exit 1
+  fi
+}
+
+main() {
+  if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <hostname>" >&2
+    exit 1
+  fi
+
+  if [ -f "$(which hostnamectl)" ]; then
+    execute hostnamectl set-hostname "$1"
+  else
+    echo "Error: hostnamectl is not installed." >&2
+    exit 1
+  fi
+}
+
+main "$@"
diff --git a/ci/linux/scripts/start-tailscale.sh b/ci/linux/scripts/start-tailscale.sh
new file mode 100644
index 00000000000000..3b519bfdf59339
--- /dev/null
+++ b/ci/linux/scripts/start-tailscale.sh
@@ -0,0 +1,22 @@
+#!/bin/sh
+
+# This script starts tailscale on the current machine.
+
+execute() {
+  echo "$ $@" >&2
+  if ! "$@"; then
+    echo "Command failed: $@" >&2
+    exit 1
+  fi
+}
+
+main() {
+  if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <auth-key>" >&2
+    exit 1
+  fi
+
+  execute tailscale up --reset --ssh --accept-risk=lose-ssh --auth-key="$1"
+}
+
+main "$@"
diff --git a/ci/package.json b/ci/package.json
index ffb1297dcdd3a9..28bd56c959fcd2 100644
--- a/ci/package.json
+++ b/ci/package.json
@@ -2,7 +2,7 @@
   "private": true,
   "scripts": {
     "bootstrap": "brew install gh jq cirruslabs/cli/tart cirruslabs/cli/sshpass hashicorp/tap/packer && packer init darwin",
-    "login": "gh auth token | tart login ghcr.io --username $(gh api user --jq .login) --password-stdin",
+    "login": "token=$(gh auth token); username=$(gh api user --jq .login); echo \"Login as $username...\"; echo \"$token\" | tart login ghcr.io --username \"$username\" --password-stdin; echo \"$token\" | docker login ghcr.io --username \"$username\" --password-stdin",
     "fetch:image-name": "echo ghcr.io/oven-sh/bun-vm",
     "fetch:darwin-version": "echo 1",
     "fetch:macos-version": "sw_vers -productVersion | cut -d. -f1",
diff --git a/cmake/CompilerFlags.cmake b/cmake/CompilerFlags.cmake
index bf8cf576abf7e9..31d738134a0af1 100644
--- a/cmake/CompilerFlags.cmake
+++ b/cmake/CompilerFlags.cmake
@@ -265,7 +265,7 @@ if(ENABLE_LTO)
 endif()
 
 # --- Remapping ---
-if(UNIX)
+if(UNIX AND CI)
   register_compiler_flags(
     DESCRIPTION "Remap source files"
     -ffile-prefix-map=${CWD}=.
diff --git a/cmake/Globals.cmake b/cmake/Globals.cmake
index 9760101274181a..106e1285ea586d 100644
--- a/cmake/Globals.cmake
+++ b/cmake/Globals.cmake
@@ -105,14 +105,6 @@ else()
   unsupported(CMAKE_HOST_SYSTEM_NAME)
 endif()
 
-if(EXISTS "/lib/ld-musl-aarch64.so.1")
-  set(IS_MUSL ON)
-elseif(EXISTS "/lib/ld-musl-x86_64.so.1")
-  set(IS_MUSL ON)
-else()
-  set(IS_MUSL OFF)
-endif()
-
 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
   set(HOST_OS "aarch64")
 elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64|X86_64|x64|X64|amd64|AMD64")
@@ -144,6 +136,16 @@ else()
   set(WARNING WARNING)
 endif()
 
+if(LINUX)
+  if(EXISTS "/etc/alpine-release")
+    set(DEFAULT_ABI "musl")
+  else()
+    set(DEFAULT_ABI "gnu")
+  endif()
+
+  optionx(ABI "musl|gnu" "The ABI to use (e.g. musl, gnu)" DEFAULT ${DEFAULT_ABI})
+endif()
+
 # TODO: This causes flaky zig builds in CI, so temporarily disable it.
 # if(CI)
 #   set(DEFAULT_VENDOR_PATH ${CACHE_PATH}/vendor)
diff --git a/cmake/targets/BuildBun.cmake b/cmake/targets/BuildBun.cmake
index 9976d8dae339af..c27d820afee4ba 100644
--- a/cmake/targets/BuildBun.cmake
+++ b/cmake/targets/BuildBun.cmake
@@ -484,14 +484,12 @@ set(BUN_ZIG_OUTPUT ${BUILD_PATH}/bun-zig.o)
 
 
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM|arm64|ARM64|aarch64|AARCH64")
-  set(IS_ARM64 ON)
   if(APPLE)
     set(ZIG_CPU "apple_m1")
   else()
     set(ZIG_CPU "native")
   endif()
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|X86_64|x64|X64|amd64|AMD64")
-  set(IS_X86_64 ON)
   if(ENABLE_BASELINE)
     set(ZIG_CPU "nehalem")
   else()
@@ -528,6 +526,7 @@ register_command(
       -Dcanary=${CANARY_REVISION}
       -Dcodegen_path=${CODEGEN_PATH}
       -Dcodegen_embed=$<IF:$<BOOL:${CODEGEN_EMBED}>,true,false>
+      --prominent-compile-errors
       ${ZIG_FLAGS_BUN}
   ARTIFACTS
     ${BUN_ZIG_OUTPUT}
@@ -760,8 +759,8 @@ if(NOT WIN32)
   )
   if(DEBUG)
     # TODO: this shouldn't be necessary long term
-    if (NOT IS_MUSL)
-      set(ABI_PUBLIC_FLAGS
+    if (NOT ABI STREQUAL "musl")
+      target_compile_options(${bun} PUBLIC
         -fsanitize=null
         -fsanitize-recover=all
         -fsanitize=bounds
@@ -772,14 +771,9 @@ if(NOT WIN32)
         -fsanitize=returns-nonnull-attribute
         -fsanitize=unreachable
       )
-      set(ABI_PRIVATE_FLAGS
+      target_link_libraries(${bun} PRIVATE
         -fsanitize=null
       )
-    else()
-      set(ABI_PUBLIC_FLAGS
-      )
-      set(ABI_PRIVATE_FLAGS
-      )
     endif()
 
     target_compile_options(${bun} PUBLIC
@@ -797,10 +791,6 @@ if(NOT WIN32)
       -Wno-unused-function
       -Wno-nullability-completeness
       -Werror
-      ${ABI_PUBLIC_FLAGS}
-    )
-    target_link_libraries(${bun} PRIVATE
-      ${ABI_PRIVATE_FLAGS}
     )
   else()
     # Leave -Werror=unused off in release builds so we avoid errors from being used in ASSERT
@@ -845,65 +835,48 @@ if(WIN32)
       /delayload:IPHLPAPI.dll
     )
   endif()
-elseif(APPLE)
+endif()
+
+if(APPLE)
   target_link_options(${bun} PUBLIC
     -dead_strip
     -dead_strip_dylibs
+    -Wl,-ld_new
+    -Wl,-no_compact_unwind
     -Wl,-stack_size,0x1200000
     -fno-keep-static-consts
+    -Wl,-map,${bun}.linker-map
   )
-else()
-  # Try to use lld-16 if available, otherwise fallback to lld
-  # Cache it so we don't have to re-run CMake to pick it up
-  if((NOT DEFINED LLD_NAME) AND (NOT CI OR BUN_LINK_ONLY))
-    find_program(LLD_EXECUTABLE_NAME lld-${LLVM_VERSION_MAJOR})
-
-    if(NOT LLD_EXECUTABLE_NAME)
-      if(CI)
-        # Ensure we don't use a differing version of lld in CI vs clang
-        message(FATAL_ERROR "lld-${LLVM_VERSION_MAJOR} not found. Please make sure you have LLVM ${LLVM_VERSION_MAJOR}.x installed and set to lld-${LLVM_VERSION_MAJOR}")
-      endif()
-
-      # To make it easier for contributors, allow differing versions of lld vs clang/cmake
-      find_program(LLD_EXECUTABLE_NAME lld)
-    endif()
+endif()
 
-    if(NOT LLD_EXECUTABLE_NAME)
-      message(FATAL_ERROR "LLD not found. Please make sure you have LLVM ${LLVM_VERSION_MAJOR}.x installed and lld is available in your PATH as lld-${LLVM_VERSION_MAJOR}")
+if(LINUX)
+  if(NOT ABI STREQUAL "musl")
+    if(ARCH STREQUAL "aarch64")
+      target_link_options(${bun} PUBLIC
+        -Wl,--wrap=fcntl64
+        -Wl,--wrap=statx
+      )
+    endif()
+    
+    if(ARCH STREQUAL "x64")
+      target_link_options(${bun} PUBLIC
+        -Wl,--wrap=fcntl
+        -Wl,--wrap=fcntl64
+        -Wl,--wrap=fstat
+        -Wl,--wrap=fstat64
+        -Wl,--wrap=fstatat
+        -Wl,--wrap=fstatat64
+        -Wl,--wrap=lstat
+        -Wl,--wrap=lstat64
+        -Wl,--wrap=mknod
+        -Wl,--wrap=mknodat
+        -Wl,--wrap=stat
+        -Wl,--wrap=stat64
+        -Wl,--wrap=statx
+      )
     endif()
 
-    # normalize to basename so it can be used with -fuse-ld
-    get_filename_component(LLD_NAME ${LLD_EXECUTABLE_NAME} NAME CACHE)
-    message(STATUS "Using linker: ${LLD_NAME} (${LLD_EXECUTABLE_NAME})")
-  elseif(NOT DEFINED LLD_NAME)
-    set(LLD_NAME lld-${LLVM_VERSION_MAJOR})
-  endif()
-
-  if (IS_ARM64)
-    set(ARCH_WRAP_FLAGS
-      -Wl,--wrap=fcntl64
-      -Wl,--wrap=statx
-    )
-  elseif(IS_X86_64)
-    set(ARCH_WRAP_FLAGS
-      -Wl,--wrap=fcntl
-      -Wl,--wrap=fcntl64
-      -Wl,--wrap=fstat
-      -Wl,--wrap=fstat64
-      -Wl,--wrap=fstatat
-      -Wl,--wrap=fstatat64
-      -Wl,--wrap=lstat
-      -Wl,--wrap=lstat64
-      -Wl,--wrap=mknod
-      -Wl,--wrap=mknodat
-      -Wl,--wrap=stat
-      -Wl,--wrap=stat64
-      -Wl,--wrap=statx
-    )
-  endif()
-
-  if (NOT IS_MUSL)
-    set(ABI_WRAP_FLAGS
+    target_link_options(${bun} PUBLIC
       -Wl,--wrap=cosf
       -Wl,--wrap=exp
       -Wl,--wrap=expf
@@ -920,26 +893,37 @@ else()
       -Wl,--wrap=sinf
       -Wl,--wrap=tanf
     )
+  endif()
+
+  if(NOT ABI STREQUAL "musl")
+    target_link_options(${bun} PUBLIC
+      -static-libstdc++
+      -static-libgcc
+    )
   else()
-    set(ABI_WRAP_FLAGS
+    target_link_options(${bun} PUBLIC
+      -lstdc++
+      -lgcc
     )
   endif()
 
   target_link_options(${bun} PUBLIC
-    -fuse-ld=${LLD_NAME}
+    --ld-path=${LLD_PROGRAM}
     -fno-pic
-    -static-libstdc++
-    -static-libgcc
     -Wl,-no-pie
     -Wl,-icf=safe
     -Wl,--as-needed
     -Wl,--gc-sections
     -Wl,-z,stack-size=12800000
-    ${ARCH_WRAP_FLAGS}
-    ${ABI_WRAP_FLAGS}
     -Wl,--compress-debug-sections=zlib
     -Wl,-z,lazy
     -Wl,-z,norelro
+    -Wl,-z,combreloc
+    -Wl,--no-eh-frame-hdr
+    -Wl,--sort-section=name
+    -Wl,--hash-style=gnu
+    -Wl,--build-id=sha1  # Better for debugging than default
+    -Wl,-Map=${bun}.linker-map
   )
 endif()
 
@@ -1079,6 +1063,18 @@ endif()
 # --- Packaging ---
 
 if(NOT BUN_CPP_ONLY)
+  set(CMAKE_STRIP_FLAGS "")
+  if(APPLE)
+    # We do not build with exceptions enabled. These are generated by lolhtml
+    # and other dependencies. We build lolhtml with abort on panic, so it
+    # shouldn't be including these in the first place.
+    set(CMAKE_STRIP_FLAGS --remove-section=__TEXT,__eh_frame --remove-section=__TEXT,__unwind_info --remove-section=__TEXT,__gcc_except_tab)
+  elseif(LINUX AND NOT ABI STREQUAL "musl")
+    # When you use llvm-strip to do this, it doesn't delete it from the binary and instead keeps it as [LOAD #2 [R]]
+    # So, we must use GNU strip to do this.
+    set(CMAKE_STRIP_FLAGS -R .eh_frame -R .gcc_except_table)
+  endif()
+
   if(bunStrip)
     register_command(
       TARGET
@@ -1090,6 +1086,7 @@ if(NOT BUN_CPP_ONLY)
       COMMAND
         ${CMAKE_STRIP}
           ${bunExe}
+          ${CMAKE_STRIP_FLAGS}
           --strip-all
           --strip-debug
           --discard-all
@@ -1165,10 +1162,12 @@ if(NOT BUN_CPP_ONLY)
   endif()
 
   if(CI)
+    set(bunTriplet bun-${OS}-${ARCH})
+    if(ABI STREQUAL "musl")
+      set(bunTriplet ${bunTriplet}-musl)
+    endif()
     if(ENABLE_BASELINE)
-      set(bunTriplet bun-${OS}-${ARCH}-baseline)
-    else()
-      set(bunTriplet bun-${OS}-${ARCH})
+      set(bunTriplet ${bunTriplet}-baseline)
     endif()
     string(REPLACE bun ${bunTriplet} bunPath ${bun})
     set(bunFiles ${bunExe} features.json)
@@ -1177,6 +1176,12 @@ if(NOT BUN_CPP_ONLY)
     elseif(APPLE)
       list(APPEND bunFiles ${bun}.dSYM)
     endif()
+
+    if(APPLE OR LINUX)
+      list(APPEND bunFiles ${bun}.linker-map)
+    endif()
+
+
     register_command(
       TARGET
         ${bun}
diff --git a/cmake/targets/BuildLolHtml.cmake b/cmake/targets/BuildLolHtml.cmake
index 9a02362723960e..aeac571321c24d 100644
--- a/cmake/targets/BuildLolHtml.cmake
+++ b/cmake/targets/BuildLolHtml.cmake
@@ -26,6 +26,13 @@ if(RELEASE)
   list(APPEND LOLHTML_BUILD_ARGS --release)
 endif()
 
+# Windows requires unwind tables, apparently.
+if (NOT WIN32)
+  # The encoded escape sequences are intentional. They're how you delimit multiple arguments in a single environment variable.
+  # Also add rust optimization flag for smaller binary size, but not huge speed penalty.
+  set(RUSTFLAGS "-Cpanic=abort-Cdebuginfo=0-Cforce-unwind-tables=no-Copt-level=s")
+endif()
+
 register_command(
   TARGET
     lolhtml
@@ -37,6 +44,11 @@ register_command(
       ${LOLHTML_BUILD_ARGS}
   ARTIFACTS
     ${LOLHTML_LIBRARY}
+  ENVIRONMENT
+    CARGO_TERM_COLOR=always
+    CARGO_TERM_VERBOSE=true
+    CARGO_TERM_DIAGNOSTIC=true
+    CARGO_ENCODED_RUSTFLAGS=${RUSTFLAGS}
 )
 
 target_link_libraries(${bun} PRIVATE ${LOLHTML_LIBRARY})
diff --git a/cmake/toolchains/linux-aarch64-musl.cmake b/cmake/toolchains/linux-aarch64-musl.cmake
new file mode 100644
index 00000000000000..e4a33f709e88cd
--- /dev/null
+++ b/cmake/toolchains/linux-aarch64-musl.cmake
@@ -0,0 +1,6 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+set(ABI musl)
+
+set(CMAKE_C_COMPILER_WORKS ON)
+set(CMAKE_CXX_COMPILER_WORKS ON)
\ No newline at end of file
diff --git a/cmake/toolchains/linux-aarch64.cmake b/cmake/toolchains/linux-aarch64.cmake
index bc23a063020bea..657594dae8c513 100644
--- a/cmake/toolchains/linux-aarch64.cmake
+++ b/cmake/toolchains/linux-aarch64.cmake
@@ -1,5 +1,6 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
+set(ABI gnu)
 
 set(CMAKE_C_COMPILER_WORKS ON)
 set(CMAKE_CXX_COMPILER_WORKS ON)
\ No newline at end of file
diff --git a/cmake/toolchains/linux-x64-baseline.cmake b/cmake/toolchains/linux-x64-baseline.cmake
index f521cfcc4afc14..73d6bc61e4946e 100644
--- a/cmake/toolchains/linux-x64-baseline.cmake
+++ b/cmake/toolchains/linux-x64-baseline.cmake
@@ -1,6 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR x64)
 set(ENABLE_BASELINE ON)
+set(ABI gnu)
 
 set(CMAKE_C_COMPILER_WORKS ON)
 set(CMAKE_CXX_COMPILER_WORKS ON)
\ No newline at end of file
diff --git a/cmake/toolchains/linux-x64-musl-baseline.cmake b/cmake/toolchains/linux-x64-musl-baseline.cmake
new file mode 100644
index 00000000000000..ea28a1757ac8d0
--- /dev/null
+++ b/cmake/toolchains/linux-x64-musl-baseline.cmake
@@ -0,0 +1,7 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR x64)
+set(ENABLE_BASELINE ON)
+set(ABI musl)
+
+set(CMAKE_C_COMPILER_WORKS ON)
+set(CMAKE_CXX_COMPILER_WORKS ON)
\ No newline at end of file
diff --git a/cmake/toolchains/linux-x64-musl.cmake b/cmake/toolchains/linux-x64-musl.cmake
new file mode 100644
index 00000000000000..db4998bba9d510
--- /dev/null
+++ b/cmake/toolchains/linux-x64-musl.cmake
@@ -0,0 +1,6 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR x64)
+set(ABI musl)
+
+set(CMAKE_C_COMPILER_WORKS ON)
+set(CMAKE_CXX_COMPILER_WORKS ON)
diff --git a/cmake/toolchains/linux-x64.cmake b/cmake/toolchains/linux-x64.cmake
index 66bc7a592fd0dd..4104a1c5df7396 100644
--- a/cmake/toolchains/linux-x64.cmake
+++ b/cmake/toolchains/linux-x64.cmake
@@ -1,5 +1,6 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(CMAKE_SYSTEM_PROCESSOR x64)
+set(ABI gnu)
 
 set(CMAKE_C_COMPILER_WORKS ON)
 set(CMAKE_CXX_COMPILER_WORKS ON)
diff --git a/cmake/tools/SetupGit.cmake b/cmake/tools/SetupGit.cmake
index 8e0f87c3120ac5..769735b7b0946c 100644
--- a/cmake/tools/SetupGit.cmake
+++ b/cmake/tools/SetupGit.cmake
@@ -29,7 +29,7 @@ execute_process(
 )
 
 if(NOT GIT_DIFF_RESULT EQUAL 0)
-  message(${WARNING} "Command failed: ${GIT_DIFF_COMMAND} ${GIT_DIFF_ERROR}")
+  message(WARNING "Command failed: ${GIT_DIFF_COMMAND} ${GIT_DIFF_ERROR}")
   return()
 endif()
 
diff --git a/cmake/tools/SetupLLVM.cmake b/cmake/tools/SetupLLVM.cmake
index a7046d996f4791..5e5fd3a9532a71 100644
--- a/cmake/tools/SetupLLVM.cmake
+++ b/cmake/tools/SetupLLVM.cmake
@@ -4,7 +4,7 @@ if(NOT ENABLE_LLVM)
   return()
 endif()
 
-if(CMAKE_HOST_WIN32 OR CMAKE_HOST_APPLE OR IS_MUSL)
+if(CMAKE_HOST_WIN32 OR CMAKE_HOST_APPLE OR ABI STREQUAL "musl")
   set(DEFAULT_LLVM_VERSION "18.1.8")
 else()
   set(DEFAULT_LLVM_VERSION "16.0.6")
@@ -52,6 +52,7 @@ if(UNIX)
       /usr/lib/llvm-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}/bin
       /usr/lib/llvm-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}/bin
       /usr/lib/llvm-${LLVM_VERSION_MAJOR}/bin
+      /usr/lib/llvm${LLVM_VERSION_MAJOR}/bin
     )
   endif()
 endif()
@@ -108,8 +109,23 @@ else()
   find_llvm_command(CMAKE_CXX_COMPILER clang++)
   find_llvm_command(CMAKE_LINKER llvm-link)
   find_llvm_command(CMAKE_AR llvm-ar)
-  find_llvm_command(CMAKE_STRIP llvm-strip)
+  if (LINUX)
+    # On Linux, strip ends up being more useful for us.
+    find_command(
+      VARIABLE
+        CMAKE_STRIP
+      COMMAND
+        strip
+      REQUIRED
+        ON
+    )
+  else()
+    find_llvm_command(CMAKE_STRIP llvm-strip)
+  endif()
   find_llvm_command(CMAKE_RANLIB llvm-ranlib)
+  if(LINUX)
+    find_llvm_command(LLD_PROGRAM ld.lld)
+  endif()
   if(APPLE)
     find_llvm_command(CMAKE_DSYMUTIL dsymutil)
   endif()
diff --git a/cmake/tools/SetupWebKit.cmake b/cmake/tools/SetupWebKit.cmake
index 677c8c0ad392b3..2cdea17edc99b7 100644
--- a/cmake/tools/SetupWebKit.cmake
+++ b/cmake/tools/SetupWebKit.cmake
@@ -2,7 +2,7 @@ option(WEBKIT_VERSION "The version of WebKit to use")
 option(WEBKIT_LOCAL "If a local version of WebKit should be used instead of downloading")
 
 if(NOT WEBKIT_VERSION)
-  set(WEBKIT_VERSION 73b551e25d97e463e8e2c86cb819b8639fcbda06)
+  set(WEBKIT_VERSION 3bc4abf2d5875baf500b4687ef869987f6d19e00)
 endif()
 
 if(WEBKIT_LOCAL)
@@ -63,7 +63,7 @@ else()
   message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
 endif()
 
-if(IS_MUSL)
+if(ABI STREQUAL "musl")
   set(WEBKIT_SUFFIX "-musl")
 endif()
 
diff --git a/cmake/tools/SetupZig.cmake b/cmake/tools/SetupZig.cmake
index d34c4b53ff22aa..e5a5e574ef99aa 100644
--- a/cmake/tools/SetupZig.cmake
+++ b/cmake/tools/SetupZig.cmake
@@ -11,7 +11,7 @@ if(APPLE)
 elseif(WIN32)
   set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-windows-msvc)
 elseif(LINUX)
-  if(IS_MUSL)
+  if(ABI STREQUAL "musl")
     set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-linux-musl)
   else()
     set(DEFAULT_ZIG_TARGET ${DEFAULT_ZIG_ARCH}-linux-gnu)
diff --git a/dockerhub/alpine/Dockerfile b/dockerhub/alpine/Dockerfile
index e2bbba7aa42a3d..0ef8ce5f6ed86f 100644
--- a/dockerhub/alpine/Dockerfile
+++ b/dockerhub/alpine/Dockerfile
@@ -1,30 +1,13 @@
-FROM alpine:3.18 AS build
+FROM alpine:3.20 AS build
 
 # https://github.com/oven-sh/bun/releases
 ARG BUN_VERSION=latest
 
-# TODO: Instead of downloading glibc from a third-party source, we should
-#      build it from source. This is a temporary solution.
-#      See: https://github.com/sgerrand/alpine-pkg-glibc
-
-# https://github.com/sgerrand/alpine-pkg-glibc/releases
-# https://github.com/sgerrand/alpine-pkg-glibc/issues/176
-ARG GLIBC_VERSION=2.34-r0
-
-# https://github.com/oven-sh/bun/issues/5545#issuecomment-1722461083
-ARG GLIBC_VERSION_AARCH64=2.26-r1
-
-RUN apk --no-cache add \
-      ca-certificates \
-      curl \
-      dirmngr \
-      gpg \
-      gpg-agent \
-      unzip \
+RUN apk --no-cache add ca-certificates curl dirmngr gpg gpg-agent unzip \
     && arch="$(apk --print-arch)" \
     && case "${arch##*-}" in \
-      x86_64) build="x64-baseline";; \
-      aarch64) build="aarch64";; \
+      x86_64) build="x64-musl-baseline";; \
+      aarch64) build="aarch64-musl";; \
       *) echo "error: unsupported architecture: $arch"; exit 1 ;; \
     esac \
     && version="$BUN_VERSION" \
@@ -59,37 +42,9 @@ RUN apk --no-cache add \
     && unzip "bun-linux-$build.zip" \
     && mv "bun-linux-$build/bun" /usr/local/bin/bun \
     && rm -f "bun-linux-$build.zip" SHASUMS256.txt.asc SHASUMS256.txt \
-    && chmod +x /usr/local/bin/bun \
-    && cd /tmp \
-    && case "${arch##*-}" in \
-      x86_64) curl "https://github.com/sgerrand/alpine-pkg-glibc/releases/download/${GLIBC_VERSION}/glibc-${GLIBC_VERSION}.apk" \
-        -fsSLO \
-        --compressed \
-        --retry 5 \
-        || (echo "error: failed to download: glibc v${GLIBC_VERSION}" && exit 1) \
-      && mv "glibc-${GLIBC_VERSION}.apk" glibc.apk \
-      && curl "https://github.com/sgerrand/alpine-pkg-glibc/releases/download/${GLIBC_VERSION}/glibc-bin-${GLIBC_VERSION}.apk" \
-        -fsSLO \
-        --compressed \
-        --retry 5 \
-        || (echo "error: failed to download: glibc-bin v${GLIBC_VERSION}" && exit 1) \
-      && mv "glibc-bin-${GLIBC_VERSION}.apk" glibc-bin.apk ;; \
-      aarch64) curl "https://raw.githubusercontent.com/squishyu/alpine-pkg-glibc-aarch64-bin/master/glibc-${GLIBC_VERSION_AARCH64}.apk" \
-        -fsSLO \
-        --compressed \
-        --retry 5 \
-        || (echo "error: failed to download: glibc v${GLIBC_VERSION_AARCH64}" && exit 1) \
-      && mv "glibc-${GLIBC_VERSION_AARCH64}.apk" glibc.apk \
-      && curl "https://raw.githubusercontent.com/squishyu/alpine-pkg-glibc-aarch64-bin/master/glibc-bin-${GLIBC_VERSION_AARCH64}.apk" \
-        -fsSLO \
-        --compressed \
-        --retry 5 \
-        || (echo "error: failed to download: glibc-bin v${GLIBC_VERSION_AARCH64}" && exit 1) \
-      && mv "glibc-bin-${GLIBC_VERSION_AARCH64}.apk" glibc-bin.apk ;; \
-      *) echo "error: unsupported architecture '$arch'"; exit 1 ;; \
-    esac
+    && chmod +x /usr/local/bin/bun
 
-FROM alpine:3.18
+FROM alpine:3.20
 
 # Disable the runtime transpiler cache by default inside Docker containers.
 # On ephemeral containers, the cache is not useful
@@ -107,10 +62,8 @@ COPY docker-entrypoint.sh /usr/local/bin/
 RUN --mount=type=bind,from=build,source=/tmp,target=/tmp \
     addgroup -g 1000 bun \
     && adduser -u 1000 -G bun -s /bin/sh -D bun \
-    && apk --no-cache --force-overwrite --allow-untrusted add \
-      /tmp/glibc.apk \
-      /tmp/glibc-bin.apk \
     && ln -s /usr/local/bin/bun /usr/local/bin/bunx \
+    && apk add libgcc libstdc++ \
     && which bun \
     && which bunx \
     && bun --version
diff --git a/docs/cli/test.md b/docs/cli/test.md
index 3a9ec639a5d930..8ff796f5b02d05 100644
--- a/docs/cli/test.md
+++ b/docs/cli/test.md
@@ -55,6 +55,49 @@ $ bun test ./test/specific-file.test.ts
 
 The test runner runs all tests in a single process. It loads all `--preload` scripts (see [Lifecycle](https://bun.sh/docs/test/lifecycle) for details), then runs all tests. If a test fails, the test runner will exit with a non-zero exit code.
 
+## CI/CD integration
+
+`bun test` supports a variety of CI/CD integrations.
+
+### GitHub Actions
+
+`bun test` automatically detects if it's running inside GitHub Actions and will emit GitHub Actions annotations to the console directly.
+
+No configuration is needed, other than installing `bun` in the workflow and running `bun test`.
+
+#### How to install `bun` in a GitHub Actions workflow
+
+To use `bun test` in a GitHub Actions workflow, add the following step:
+
+```yaml
+jobs:
+  build:
+    name: build-app
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install bun
+        uses: oven-sh/setup-bun
+      - name: Install dependencies # (assuming your project has dependencies)
+        run: bun install # You can use npm/yarn/pnpm instead if you prefer
+      - name: Run tests
+        run: bun test
+```
+
+From there, you'll get GitHub Actions annotations.
+
+### JUnit XML reports (GitLab, etc.)
+
+To use `bun test` with a JUnit XML reporter, you can use the `--reporter=junit` in combination with `--reporter-outfile`.
+
+```sh
+$ bun test --reporter=junit --reporter-outfile=./bun.xml
+```
+
+This will continue to output to stdout/stderr as usual, and also write a JUnit
+XML report to the given path at the very end of the test run.
+
+JUnit XML is a popular format for reporting test results in CI/CD pipelines.
+
 ## Timeouts
 
 Use the `--timeout` flag to specify a _per-test_ timeout in milliseconds. If a test times out, it will be marked as failed. The default value is `5000`.
diff --git a/docs/dev/bundev.md b/docs/dev/bundev.md
deleted file mode 100644
index baccf7658ab27f..00000000000000
--- a/docs/dev/bundev.md
+++ /dev/null
@@ -1,11 +0,0 @@
-- pages
-- auto-bundle dependencies
-- pages is function that returns a list of pages?
-- plugins for svelte and vue
-- custom loaders
-- HMR
-- server endpoints
-
-```ts
-Bun.serve({});
-```
diff --git a/docs/dev/cra.md b/docs/dev/cra.md
deleted file mode 100644
index 8eb86871503342..00000000000000
--- a/docs/dev/cra.md
+++ /dev/null
@@ -1,31 +0,0 @@
-To create a new React app:
-
-```bash
-$ bun create react ./app
-$ cd app
-$ bun dev # start dev server
-```
-
-To use an existing React app:
-
-```bash
-$ bun add -d react-refresh # install React Fast Refresh
-$ bun bun ./src/index.js # generate a bundle for your entry point(s)
-$ bun dev # start the dev server
-```
-
-From there, Bun relies on the filesystem for mapping dev server paths to source files. All URL paths are relative to the project root (where `package.json` is located).
-
-Here are examples of routing source code file paths:
-
-| Dev Server URL             | File Path (relative to cwd) |
-| -------------------------- | --------------------------- |
-| /src/components/Button.tsx | src/components/Button.tsx   |
-| /src/index.tsx             | src/index.tsx               |
-| /pages/index.js            | pages/index.js              |
-
-You do not need to include file extensions in `import` paths. CommonJS-style import paths without the file extension work.
-
-You can override the public directory by passing `--public-dir="path-to-folder"`.
-
-If no directory is specified and `./public/` doesn’t exist, Bun will try `./static/`. If `./static/` does not exist, but won’t serve from a public directory. If you pass `--public-dir=./` Bun will serve from the current directory, but it will check the current directory last instead of first.
diff --git a/docs/dev/css.md b/docs/dev/css.md
deleted file mode 100644
index 53ebc6c0666f77..00000000000000
--- a/docs/dev/css.md
+++ /dev/null
@@ -1,77 +0,0 @@
-## With `bun dev`
-
-When importing CSS in JavaScript-like loaders, CSS is treated special.
-
-By default, Bun will transform a statement like this:
-
-```js
-import "../styles/global.css";
-```
-
-### When `platform` is `browser`
-
-```js
-globalThis.document?.dispatchEvent(
-  new CustomEvent("onimportcss", {
-    detail: "http://localhost:3000/styles/globals.css",
-  }),
-);
-```
-
-An event handler for turning that into a `<link>` is automatically registered when HMR is enabled. That event handler can be turned off either in a framework’s `package.json` or by setting `globalThis["Bun_disableCSSImports"] = true;` in client-side code. Additionally, you can get a list of every .css file imported this way via `globalThis["__BUN"].allImportedStyles`.
-
-### When `platform` is `bun`
-
-```js
-//@import url("http://localhost:3000/styles/globals.css");
-```
-
-Additionally, Bun exposes an API for SSR/SSG that returns a flat list of URLs to css files imported. That function is `Bun.getImportedStyles()`.
-
-```ts
-// This specifically is for "framework" in package.json when loaded via `bun dev`
-// This API needs to be changed somewhat to work more generally with Bun.js
-// Initially, you could only use Bun.js through `bun dev`
-// and this API was created at that time
-addEventListener("fetch", async (event: FetchEvent) => {
-  let route = Bun.match(event);
-  const App = await import("pages/_app");
-
-  // This returns all .css files that were imported in the line above.
-  // It’s recursive, so any file that imports a CSS file will be included.
-  const appStylesheets = bun.getImportedStyles();
-
-  // ...rest of code
-});
-```
-
-This is useful for preventing flash of unstyled content.
-
-## With `bun bun`
-
-Bun bundles `.css` files imported via `@import` into a single file. It doesn’t auto-prefix or minify CSS today. Multiple `.css` files imported in one JavaScript file will _not_ be bundled into one file. You’ll have to import those from a `.css` file.
-
-This input:
-
-```css
-@import url("./hi.css");
-@import url("./hello.css");
-@import url("./yo.css");
-```
-
-Becomes:
-
-```css
-/* hi.css */
-/* ...contents of hi.css */
-/* hello.css */
-/* ...contents of hello.css */
-/* yo.css */
-/* ...contents of yo.css */
-```
-
-## CSS runtime
-
-To support hot CSS reloading, Bun inserts `@supports` annotations into CSS that tag which files a stylesheet is composed of. Browsers ignore this, so it doesn’t impact styles.
-
-By default, Bun’s runtime code automatically listens to `onimportcss` and will insert the `event.detail` into a `<link rel="stylesheet" href={${event.detail}}>` if there is no existing `link` tag with that stylesheet. That’s how Bun’s equivalent of `style-loader` works.
diff --git a/docs/dev/discord.md b/docs/dev/discord.md
deleted file mode 100644
index d3e9c5a2b7ab18..00000000000000
--- a/docs/dev/discord.md
+++ /dev/null
@@ -1,26 +0,0 @@
-## Creating a Discord bot with Bun
-
-Discord bots perform actions in response to _application commands_. There are 3 types of commands accessible in different interfaces: the chat input, a message's context menu (top-right menu or right-clicking in a message), and a user's context menu (right-clicking on a user).
-
-To get started you can use the interactions template:
-
-```bash
-bun create discord-interactions my-interactions-bot
-cd my-interactions-bot
-```
-
-If you don't have a Discord bot/application yet, you can create one [here (https://discord.com/developers/applications/me)](https://discord.com/developers/applications/me).
-
-Invite bot to your server by visiting `https://discord.com/api/oauth2/authorize?client_id=<your_application_id>&scope=bot%20applications.commands`
-
-Afterwards you will need to get your bot's token, public key, and application id from the application page and put them into `.env.example` file
-
-Then you can run the http server that will handle your interactions:
-
-```bash
-$ bun install
-$ mv .env.example .env
-$ bun run.js # listening on port 1337
-```
-
-Discord does not accept an insecure HTTP server, so you will need to provide an SSL certificate or put the interactions server behind a secure reverse proxy. For development, you can use ngrok/cloudflare tunnel to expose local ports as secure URL.
diff --git a/docs/guides/http/cluster.md b/docs/guides/http/cluster.md
index 7d5e8b992d0c07..c434337d79f702 100644
--- a/docs/guides/http/cluster.md
+++ b/docs/guides/http/cluster.md
@@ -63,4 +63,4 @@ process.on("exit", kill);
 
 ---
 
-At the time of writing, Bun hasn't implemented the `node:cluster` module yet, but this is a faster, simple, and limited alternative. We will also implement `node:cluster` in the future.
+Bun has also implemented the `node:cluster` module, but this is a faster, simple, and limited alternative.
diff --git a/docs/guides/test/todo-tests.md b/docs/guides/test/todo-tests.md
index 577843206c6bad..da9bd9e70c7897 100644
--- a/docs/guides/test/todo-tests.md
+++ b/docs/guides/test/todo-tests.md
@@ -44,10 +44,17 @@ test.todo("unimplemented feature", () => {
 
 ---
 
-If an implementation is provided, it will be executed and _expected to fail_ by test runner! If a todo test passes, the `bun test` run will return a non-zero exit code to signal the failure.
+If an implementation is provided, it will not be run unless the `--todo` flag is passed. If the `--todo` flag is passed, the test will be executed and _expected to fail_ by test runner! If a todo test passes, the `bun test` run will return a non-zero exit code to signal the failure.
 
 ```sh
-$ bun test
+$ bun test --todo
+my.test.ts:
+✗ unimplemented feature
+  ^ this test is marked as todo but passes. Remove `.todo` or check that test is correct.
+
+ 0 pass
+ 1 fail
+ 1 expect() calls
 $ echo $?
 1 # this is the exit code of the previous command
 ```
diff --git a/docs/project/building-windows.md b/docs/project/building-windows.md
index 041207c9ff25cd..8831bd5c448433 100644
--- a/docs/project/building-windows.md
+++ b/docs/project/building-windows.md
@@ -73,15 +73,10 @@ After Visual Studio, you need the following:
 **Note** – The Zig compiler is automatically downloaded, installed, and updated by the building process.
 {% /callout %}
 
-[WinGet](https://learn.microsoft.com/windows/package-manager/winget) or [Scoop](https://scoop.sh) can be used to install these remaining tools easily:
+[Scoop](https://scoop.sh) can be used to install these remaining tools easily.
 
 {% codetabs group="a" %}
 
-```ps1#WinGet
-## Select "Add LLVM to the system PATH for all users" in the LLVM installer
-> winget install -i LLVM.LLVM -v 18.1.8 && winget install GoLang.Go Rustlang.Rustup NASM.NASM StrawberryPerl.StrawberryPerl RubyInstallerTeam.Ruby.3.2 OpenJS.NodeJS.LTS Ccache.Ccache
-```
-
 ```ps1#Scoop
 > irm https://get.scoop.sh | iex
 > scoop install nodejs-lts go rust nasm ruby perl ccache
@@ -91,20 +86,16 @@ After Visual Studio, you need the following:
 
 {% /codetabs %}
 
-If you intend on building WebKit locally (optional), you should install these packages:
-
-{% codetabs group="a" %}
+{% callout %}
+Please do not use WinGet/other package manager for these, as you will likely install Strawberry Perl instead of a more minimal installation of Perl. Strawberry Perl includes many other utilities that get installed into `$Env:PATH` that will conflict with MSVC and break the build.
+{% /callout %}
 
-```ps1#WinGet
-> winget install ezwinports.make Cygwin.Cygwin Python.Python.3.12
-```
+If you intend on building WebKit locally (optional), you should install these packages:
 
 ```ps1#Scoop
 > scoop install make cygwin python
 ```
 
-{% /codetabs %}
-
 From here on out, it is **expected you use a PowerShell Terminal with `.\scripts\vs-shell.ps1` sourced**. This script is available in the Bun repository and can be loaded by executing it:
 
 ```ps1
diff --git a/docs/rfcs/README.md b/docs/rfcs/README.md
deleted file mode 100644
index 65ef33ead849a5..00000000000000
--- a/docs/rfcs/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# RFCs
-
-| Number | Name | Issue |
-| ------ | ---- | ----- |
diff --git a/docs/test/writing.md b/docs/test/writing.md
index ab7e99c8832dce..ef1ab57de00b8a 100644
--- a/docs/test/writing.md
+++ b/docs/test/writing.md
@@ -97,7 +97,7 @@ test.skip("wat", () => {
 
 ## `test.todo`
 
-Mark a test as a todo with `test.todo`. These tests _will_ be run, and the test runner will expect them to fail. If they pass, you will be prompted to mark it as a regular test.
+Mark a test as a todo with `test.todo`. These tests will not be run.
 
 ```ts
 import { expect, test } from "bun:test";
@@ -107,12 +107,22 @@ test.todo("fix this", () => {
 });
 ```
 
-To exclusively run tests marked as _todo_, use `bun test --todo`.
+To run todo tests and find any which are passing, use `bun test --todo`.
 
 ```sh
 $ bun test --todo
+my.test.ts:
+✗ unimplemented feature
+  ^ this test is marked as todo but passes. Remove `.todo` or check that test is correct.
+
+ 0 pass
+ 1 fail
+ 1 expect() calls
 ```
 
+With this flag, failing todo tests will not cause an error, but todo tests which pass will be marked as failing so you can remove the todo mark or
+fix the test.
+
 ## `test.only`
 
 To run a particular test or suite of tests use `test.only()` or `describe.only()`. Once declared, running `bun test --only` will only execute tests/suites that have been marked with `.only()`. Running `bun test` without the `--only` option with `test.only()` declared will result in all tests in the given suite being executed _up to_ the test with `.only()`. `describe.only()` functions the same in both execution scenarios.
diff --git a/package.json b/package.json
index c8f3afe1543d05..51e442673031d4 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "bun",
-  "version": "1.1.35",
+  "version": "1.1.37",
   "workspaces": [
     "./packages/bun-types"
   ],
diff --git a/packages/bun-types/test.d.ts b/packages/bun-types/test.d.ts
index dd76ecc98a0c12..6ef3a6040380f1 100644
--- a/packages/bun-types/test.d.ts
+++ b/packages/bun-types/test.d.ts
@@ -387,9 +387,9 @@ declare module "bun:test" {
     /**
      * Marks this test as to be written or to be fixed.
      *
-     * When a test function is passed, it will be marked as `todo` in the test results
-     * as long the test does not pass. When the test passes, the test will be marked as
-     * `fail` in the results; you will have to remove the `.todo` or check that your test
+     * These tests will not be executed unless the `--todo` flag is passed. With the flag,
+     * if the test passes, the test will be marked as `fail` in the results; you will have to
+     * remove the `.todo` or check that your test
      * is implemented correctly.
      *
      * @param label the label for the test
diff --git a/packages/bun-usockets/src/crypto/openssl.c b/packages/bun-usockets/src/crypto/openssl.c
index 5880fa35cc8b0e..4c4c2a76d57d6c 100644
--- a/packages/bun-usockets/src/crypto/openssl.c
+++ b/packages/bun-usockets/src/crypto/openssl.c
@@ -201,7 +201,7 @@ struct loop_ssl_data * us_internal_set_loop_ssl_data(struct us_internal_ssl_sock
 
 struct us_internal_ssl_socket_t *ssl_on_open(struct us_internal_ssl_socket_t *s,
                                              int is_client, char *ip,
-                                             int ip_length) {
+                                             int ip_length, const char* sni) {
 
   struct us_internal_ssl_socket_context_t *context =
       (struct us_internal_ssl_socket_context_t *)us_socket_context(0, &s->s);
@@ -231,6 +231,10 @@ struct us_internal_ssl_socket_t *ssl_on_open(struct us_internal_ssl_socket_t *s,
   if (is_client) {
     SSL_set_renegotiate_mode(s->ssl, ssl_renegotiate_explicit);
     SSL_set_connect_state(s->ssl);
+
+    if (sni) {
+      SSL_set_tlsext_host_name(s->ssl, sni);
+    }
   } else {
     SSL_set_accept_state(s->ssl);
     // we do not allow renegotiation on the server side (should be the default for BoringSSL, but we set to make openssl compatible)
@@ -1603,6 +1607,10 @@ struct us_internal_ssl_socket_t *us_internal_ssl_socket_context_connect_unix(
           socket_ext_size);
 }
 
+static void ssl_on_open_without_sni(struct us_internal_ssl_socket_t *s, int is_client, char *ip, int ip_length) {
+  ssl_on_open(s, is_client, ip, ip_length, NULL);
+}
+
 void us_internal_ssl_socket_context_on_open(
     struct us_internal_ssl_socket_context_t *context,
     struct us_internal_ssl_socket_t *(*on_open)(
@@ -1611,7 +1619,7 @@ void us_internal_ssl_socket_context_on_open(
   us_socket_context_on_open(
       0, &context->sc,
       (struct us_socket_t * (*)(struct us_socket_t *, int, char *, int))
-          ssl_on_open);
+          ssl_on_open_without_sni);
   context->on_open = on_open;
 }
 
@@ -2005,7 +2013,30 @@ us_internal_ssl_socket_open(struct us_internal_ssl_socket_t *s, int is_client,
     return s;
 
   // start SSL open
-  return ssl_on_open(s, is_client, ip, ip_length);
+  return ssl_on_open(s, is_client, ip, ip_length, NULL);
+}
+
+struct us_socket_t *us_socket_upgrade_to_tls(us_socket_r s, us_socket_context_r new_context, const char *sni) {
+  // Resize to tls + ext size
+  void** prev_ext_ptr = (void**)us_socket_ext(0, s);
+  void* prev_ext = *prev_ext_ptr;
+  struct us_internal_ssl_socket_t *socket =
+      (struct us_internal_ssl_socket_t *)us_socket_context_adopt_socket(
+          0, new_context, s,
+          (sizeof(struct us_internal_ssl_socket_t) - sizeof(struct us_socket_t)) + sizeof(void*));
+  socket->ssl = NULL;
+  socket->ssl_write_wants_read = 0;
+  socket->ssl_read_wants_write = 0;
+  socket->fatal_error = 0;
+  socket->handshake_state = HANDSHAKE_PENDING;
+
+  void** new_ext_ptr = (void**)us_socket_ext(1, (struct us_socket_t *)socket);
+  *new_ext_ptr = prev_ext;
+
+  ssl_on_open(socket, 1, NULL, 0, sni);
+
+
+  return (struct us_socket_t *)socket;
 }
 
 struct us_internal_ssl_socket_t *us_internal_ssl_socket_wrap_with_tls(
diff --git a/packages/bun-usockets/src/crypto/root_certs.cpp b/packages/bun-usockets/src/crypto/root_certs.cpp
index 003685714cfb3d..f675a0ab16e80e 100644
--- a/packages/bun-usockets/src/crypto/root_certs.cpp
+++ b/packages/bun-usockets/src/crypto/root_certs.cpp
@@ -7,12 +7,6 @@
 #include <openssl/x509.h>
 #include <string.h>
 static const int root_certs_size = sizeof(root_certs) / sizeof(root_certs[0]);
-static X509 *root_cert_instances[sizeof(root_certs) / sizeof(root_certs[0])] = {
-    NULL};
-static X509 *root_extra_cert_instances = {NULL};
-
-static std::atomic_flag root_cert_instances_lock = ATOMIC_FLAG_INIT;
-static std::atomic_bool root_cert_instances_initialized = 0;
 
 // This callback is used to avoid the default passphrase callback in OpenSSL
 // which will typically prompt for the passphrase. The prompting is designed
@@ -78,7 +72,9 @@ us_ssl_ctx_get_X509_without_callback_from_file(const char *filename) {
   return NULL;
 }
 
-static void us_internal_init_root_certs() {
+static void us_internal_init_root_certs(X509 *root_cert_instances[sizeof(root_certs) / sizeof(root_certs[0])], X509 *&root_extra_cert_instances) {
+  static std::atomic_flag root_cert_instances_lock = ATOMIC_FLAG_INIT;
+  static std::atomic_bool root_cert_instances_initialized = 0;
   if (std::atomic_load(&root_cert_instances_initialized) == 1)
     return;
 
@@ -123,7 +119,11 @@ extern "C" X509_STORE *us_get_default_ca_store() {
     return NULL;
   }
 
-  us_internal_init_root_certs();
+  static X509 *root_cert_instances[sizeof(root_certs) / sizeof(root_certs[0])] = {
+    NULL};
+  static X509 *root_extra_cert_instances = NULL;
+
+  us_internal_init_root_certs(root_cert_instances, root_extra_cert_instances);
 
   // load all root_cert_instances on the default ca store
   for (size_t i = 0; i < root_certs_size; i++) {
diff --git a/packages/bun-usockets/src/libusockets.h b/packages/bun-usockets/src/libusockets.h
index d2719af2c90e7c..c32768fc2d4fdf 100644
--- a/packages/bun-usockets/src/libusockets.h
+++ b/packages/bun-usockets/src/libusockets.h
@@ -190,7 +190,7 @@ struct us_socket_context_options_t {
 };
 
 struct us_bun_verify_error_t {
-    long error;
+    int error;
     const char* code;
     const char* reason;
 };
@@ -338,6 +338,8 @@ struct us_loop_t *us_socket_context_loop(int ssl, us_socket_context_r context) n
  * Used mainly for "socket upgrades" such as when transitioning from HTTP to WebSocket. */
 struct us_socket_t *us_socket_context_adopt_socket(int ssl, us_socket_context_r context, us_socket_r s, int ext_size);
 
+struct us_socket_t *us_socket_upgrade_to_tls(us_socket_r s, us_socket_context_r new_context, const char *sni);
+
 /* Create a child socket context which acts much like its own socket context with its own callbacks yet still relies on the
  * parent socket context for some shared resources. Child socket contexts should be used together with socket adoptions and nothing else. */
 struct us_socket_context_t *us_create_child_socket_context(int ssl, us_socket_context_r context, int context_ext_size);
diff --git a/packages/bun-uws/src/HttpParser.h b/packages/bun-uws/src/HttpParser.h
index 457b6655724110..3eb88e353e4b0f 100644
--- a/packages/bun-uws/src/HttpParser.h
+++ b/packages/bun-uws/src/HttpParser.h
@@ -613,7 +613,9 @@ namespace uWS
             * ought to be handled as an error. */
             std::string_view transferEncodingString = req->getHeader("transfer-encoding");
             std::string_view contentLengthString = req->getHeader("content-length");
-            if (transferEncodingString.length() && contentLengthString.length()) {
+            auto transferEncodingStringLen = transferEncodingString.length();
+            auto contentLengthStringLen = contentLengthString.length();
+            if (transferEncodingStringLen && contentLengthStringLen) {
                 /* Returning fullptr is the same as calling the errorHandler */
                 /* We could be smart and set an error in the context along with this, to indicate what 
                  * http error response we might want to return */
@@ -623,6 +625,15 @@ namespace uWS
             /* Parse query */
             const char *querySeparatorPtr = (const char *) memchr(req->headers->value.data(), '?', req->headers->value.length());
             req->querySeparator = (unsigned int) ((querySeparatorPtr ? querySeparatorPtr : req->headers->value.data() + req->headers->value.length()) - req->headers->value.data());
+            
+            // lets check if content len is valid before calling requestHandler
+            if(contentLengthStringLen) {
+                remainingStreamingBytes = toUnsignedInteger(contentLengthString);
+                if (remainingStreamingBytes == UINT64_MAX) {
+                    /* Parser error */
+                    return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
+                }
+            }
 
             /* If returned socket is not what we put in we need
              * to break here as we either have upgraded to
@@ -642,7 +653,7 @@ namespace uWS
             /* RFC 9112 6.3
              * If a message is received with both a Transfer-Encoding and a Content-Length header field,
              * the Transfer-Encoding overrides the Content-Length. */
-            if (transferEncodingString.length()) {
+            if (transferEncodingStringLen) {
 
                 /* If a proxy sent us the transfer-encoding header that 100% means it must be chunked or else the proxy is
                  * not RFC 9112 compliant. Therefore it is always better to assume this is the case, since that entirely eliminates 
@@ -665,6 +676,7 @@ namespace uWS
                         dataHandler(user, chunk, chunk.length() == 0);
                     }
                     if (isParsingInvalidChunkedEncoding(remainingStreamingBytes)) {
+                        // TODO: what happen if we already responded?
                         return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
                     }
                     unsigned int consumed = (length - (unsigned int) dataToConsume.length());
@@ -672,13 +684,8 @@ namespace uWS
                     length = (unsigned int) dataToConsume.length();
                     consumedTotal += consumed;
                 }
-            } else if (contentLengthString.length()) {
-                remainingStreamingBytes = toUnsignedInteger(contentLengthString);
-                if (remainingStreamingBytes == UINT64_MAX) {
-                    /* Parser error */
-                    return {HTTP_ERROR_400_BAD_REQUEST, FULLPTR};
-                }
-
+            } else if (contentLengthStringLen) {
+              
                 if (!CONSUME_MINIMALLY) {
                     unsigned int emittable = (unsigned int) std::min<uint64_t>(remainingStreamingBytes, length);
                     dataHandler(user, std::string_view(data, emittable), emittable == remainingStreamingBytes);
diff --git a/scripts/agent.mjs b/scripts/agent.mjs
new file mode 100755
index 00000000000000..84af695374742b
--- /dev/null
+++ b/scripts/agent.mjs
@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+// An agent that starts buildkite-agent and runs others services.
+
+import { join } from "node:path";
+import { realpathSync } from "node:fs";
+import {
+  isWindows,
+  getOs,
+  getArch,
+  getKernel,
+  getAbi,
+  getAbiVersion,
+  getDistro,
+  getDistroVersion,
+  getHostname,
+  getCloud,
+  getCloudMetadataTag,
+  which,
+  getEnv,
+  writeFile,
+  spawnSafe,
+} from "./utils.mjs";
+import { parseArgs } from "node:util";
+
+/**
+ * @param {"install" | "start"} action
+ */
+async function doBuildkiteAgent(action) {
+  const username = "buildkite-agent";
+  const command = which("buildkite-agent", { required: true });
+
+  let homePath, cachePath, logsPath, agentLogPath, pidPath;
+  if (isWindows) {
+    homePath = "C:\\buildkite-agent";
+    cachePath = join(homePath, "cache");
+    logsPath = join(homePath, "logs");
+    agentLogPath = join(logsPath, "buildkite-agent.log");
+  } else {
+    homePath = "/var/lib/buildkite-agent";
+    cachePath = "/var/cache/buildkite-agent";
+    logsPath = "/var/log/buildkite-agent";
+    agentLogPath = join(logsPath, "buildkite-agent.log");
+    pidPath = join(logsPath, "buildkite-agent.pid");
+  }
+
+  async function install() {
+    const command = process.execPath;
+    const args = [realpathSync(process.argv[1]), "start"];
+
+    if (isWindows) {
+      const serviceCommand = [
+        "New-Service",
+        "-Name",
+        "buildkite-agent",
+        "-StartupType",
+        "Automatic",
+        "-BinaryPathName",
+        `${escape(command)} ${escape(args.map(escape).join(" "))}`,
+      ];
+      await spawnSafe(["powershell", "-Command", serviceCommand.join(" ")], { stdio: "inherit" });
+    }
+
+    if (isOpenRc()) {
+      const servicePath = "/etc/init.d/buildkite-agent";
+      const service = `#!/sbin/openrc-run
+        name="buildkite-agent"
+        description="Buildkite Agent"
+        command=${escape(command)}
+        command_args=${escape(args.map(escape).join(" "))}
+        command_user=${escape(username)}
+
+        pidfile=${escape(pidPath)}
+        start_stop_daemon_args=" \
+          --background \
+          --make-pidfile \
+          --stdout ${escape(agentLogPath)} \
+          --stderr ${escape(agentLogPath)}"
+
+        depend() {
+          need net
+          use dns logger
+        }
+      `;
+      writeFile(servicePath, service, { mode: 0o755 });
+      await spawnSafe(["rc-update", "add", "buildkite-agent", "default"], { stdio: "inherit", privileged: true });
+    }
+
+    if (isSystemd()) {
+      const servicePath = "/etc/systemd/system/buildkite-agent.service";
+      const service = `
+        [Unit]
+        Description=Buildkite Agent
+        After=syslog.target
+        After=network-online.target
+      
+        [Service]
+        Type=simple
+        User=${username}
+        ExecStart=${escape(command)} ${args.map(escape).join(" ")}
+        RestartSec=5
+        Restart=on-failure
+        KillMode=process
+
+        [Journal]
+        Storage=persistent
+        StateDirectory=${escape(agentLogPath)}
+      
+        [Install]
+        WantedBy=multi-user.target
+      `;
+      writeFile(servicePath, service);
+      await spawnSafe(["systemctl", "daemon-reload"], { stdio: "inherit", privileged: true });
+      await spawnSafe(["systemctl", "enable", "buildkite-agent"], { stdio: "inherit", privileged: true });
+    }
+  }
+
+  async function start() {
+    const cloud = await getCloud();
+
+    let token = getEnv("BUILDKITE_AGENT_TOKEN", false);
+    if (!token && cloud) {
+      token = await getCloudMetadataTag("buildkite:token");
+    }
+
+    let shell;
+    if (isWindows) {
+      const pwsh = which(["pwsh", "powershell"], { required: true });
+      shell = `${pwsh} -Command`;
+    } else {
+      const sh = which(["bash", "sh"], { required: true });
+      shell = `${sh} -c`;
+    }
+
+    const flags = ["enable-job-log-tmpfile", "no-feature-reporting"];
+    const options = {
+      "name": getHostname(),
+      "token": token || "xxx",
+      "shell": shell,
+      "job-log-path": logsPath,
+      "build-path": join(homePath, "builds"),
+      "hooks-path": join(homePath, "hooks"),
+      "plugins-path": join(homePath, "plugins"),
+      "experiment": "normalised-upload-paths,resolve-commit-after-checkout,agent-api",
+    };
+
+    let ephemeral;
+    if (cloud) {
+      const jobId = await getCloudMetadataTag("buildkite:job-uuid");
+      if (jobId) {
+        options["acquire-job"] = jobId;
+        flags.push("disconnect-after-job");
+        ephemeral = true;
+      }
+    }
+
+    if (ephemeral) {
+      options["git-clone-flags"] = "-v --depth=1";
+      options["git-fetch-flags"] = "-v --prune --depth=1";
+    } else {
+      options["git-mirrors-path"] = join(cachePath, "git");
+    }
+
+    const tags = {
+      "os": getOs(),
+      "arch": getArch(),
+      "kernel": getKernel(),
+      "abi": getAbi(),
+      "abi-version": getAbiVersion(),
+      "distro": getDistro(),
+      "distro-version": getDistroVersion(),
+      "cloud": cloud,
+    };
+
+    if (cloud) {
+      const requiredTags = ["robobun", "robobun2"];
+      for (const tag of requiredTags) {
+        const value = await getCloudMetadataTag(tag);
+        if (typeof value === "string") {
+          tags[tag] = value;
+        }
+      }
+    }
+
+    options["tags"] = Object.entries(tags)
+      .filter(([, value]) => value)
+      .map(([key, value]) => `${key}=${value}`)
+      .join(",");
+
+    await spawnSafe(
+      [
+        command,
+        "start",
+        ...flags.map(flag => `--${flag}`),
+        ...Object.entries(options).map(([key, value]) => `--${key}=${value}`),
+      ],
+      {
+        stdio: "inherit",
+      },
+    );
+  }
+
+  if (action === "install") {
+    await install();
+  } else if (action === "start") {
+    await start();
+  }
+}
+
+/**
+ * @returns {boolean}
+ */
+function isSystemd() {
+  return !!which("systemctl");
+}
+
+/**
+ * @returns {boolean}
+ */
+function isOpenRc() {
+  return !!which("rc-service");
+}
+
+function escape(string) {
+  return JSON.stringify(string);
+}
+
+async function main() {
+  const { positionals: args } = parseArgs({
+    allowPositionals: true,
+  });
+
+  if (!args.length || args.includes("install")) {
+    console.log("Installing agent...");
+    await doBuildkiteAgent("install");
+    console.log("Agent installed.");
+  }
+
+  if (args.includes("start")) {
+    console.log("Starting agent...");
+    await doBuildkiteAgent("start");
+    console.log("Agent started.");
+  }
+}
+
+await main();
diff --git a/scripts/bootstrap.ps1 b/scripts/bootstrap.ps1
new file mode 100755
index 00000000000000..eda27d917aa8d4
--- /dev/null
+++ b/scripts/bootstrap.ps1
@@ -0,0 +1,339 @@
+# Version: 4
+# A powershell script that installs the dependencies needed to build and test Bun.
+# This should work on Windows 10 or newer.
+
+# If this script does not work on your machine, please open an issue:
+# https://github.com/oven-sh/bun/issues
+
+# If you need to make a change to this script, such as upgrading a dependency,
+# increment the version comment to indicate that a new image should be built.
+# Otherwise, the existing image will be retroactively updated.
+
+param (
+  [Parameter(Mandatory = $false)]
+  [switch]$CI = $false,
+  [Parameter(Mandatory = $false)]
+  [switch]$Optimize = $CI
+)
+
+function Execute-Command {
+  $command = $args -join ' '
+  Write-Output "$ $command"
+
+  & $args[0] $args[1..$args.Length]
+
+  if ((-not $?) -or ($LASTEXITCODE -ne 0 -and $null -ne $LASTEXITCODE)) {
+    throw "Command failed: $command"
+  }
+}
+
+function Which {
+  param ([switch]$Required = $false)
+
+  foreach ($command in $args) {
+    $result = Get-Command $command -ErrorAction SilentlyContinue
+    if ($result -and $result.Path) {
+      return $result.Path
+    }
+  }
+
+  if ($Required) {
+    $commands = $args -join ', '
+    throw "Command not found: $commands"
+  }
+}
+
+function Install-Chocolatey {
+  if (Which choco) {
+    return
+  }
+
+  Write-Output "Installing Chocolatey..."
+  [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
+  iex -Command ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+  Refresh-Path
+}
+
+function Refresh-Path {
+  $paths = @(
+    [System.Environment]::GetEnvironmentVariable("Path", "Machine"),
+    [System.Environment]::GetEnvironmentVariable("Path", "User"),
+    [System.Environment]::GetEnvironmentVariable("Path", "Process")
+  )
+  $uniquePaths = $paths |
+    Where-Object { $_ } |
+    ForEach-Object { $_.Split(';', [StringSplitOptions]::RemoveEmptyEntries) } |
+    Where-Object { $_ -and (Test-Path $_) } |
+    Select-Object -Unique
+  $env:Path = ($uniquePaths -join ';').TrimEnd(';')
+
+  if ($env:ChocolateyInstall) {
+    Import-Module $env:ChocolateyInstall\helpers\chocolateyProfile.psm1 -ErrorAction SilentlyContinue
+  }
+}
+
+function Add-To-Path {
+  $absolutePath = Resolve-Path $args[0]
+  $currentPath = [Environment]::GetEnvironmentVariable("Path", "Machine")
+  if ($currentPath -like "*$absolutePath*") {  
+    return
+  }
+
+  $newPath = $currentPath.TrimEnd(";") + ";" + $absolutePath
+  if ($newPath.Length -ge 2048) {
+    Write-Warning "PATH is too long, removing duplicate and old entries..."
+    
+    $paths = $currentPath.Split(';', [StringSplitOptions]::RemoveEmptyEntries) | 
+      Where-Object { $_ -and (Test-Path $_) } |
+      Select-Object -Unique
+    
+    $paths += $absolutePath
+    $newPath = $paths -join ';'
+    while ($newPath.Length -ge 2048 -and $paths.Count -gt 1) {
+      $paths = $paths[1..$paths.Count]
+      $newPath = $paths -join ';'
+    }
+  }
+
+  Write-Output "Adding $absolutePath to PATH..."
+  [Environment]::SetEnvironmentVariable("Path", $newPath, "Machine")
+  Refresh-Path
+}
+
+function Install-Package {
+  param (
+    [Parameter(Mandatory = $true, Position = 0)]
+    [string]$Name,
+    [Parameter(Mandatory = $false)]
+    [string]$Command = $Name,
+    [Parameter(Mandatory = $false)]
+    [string]$Version,
+    [Parameter(Mandatory = $false)]
+    [switch]$Force = $false,
+    [Parameter(Mandatory = $false)]
+    [string[]]$ExtraArgs = @()
+  )
+
+  if (-not $Force `
+    -and (Which $Command) `
+    -and (-not $Version -or (& $Command --version) -like "*$Version*")) {
+    return
+  }
+
+  Write-Output "Installing $Name..."
+  $flags = @(
+    "--yes",
+    "--accept-license",
+    "--no-progress",
+    "--force"
+  )
+  if ($Version) {
+    $flags += "--version=$Version"
+  }
+
+  Execute-Command choco install $Name @flags @ExtraArgs
+  Refresh-Path
+}
+
+function Install-Packages {
+  foreach ($package in $args) {
+    Install-Package -Name $package
+  }
+}
+
+function Install-Common-Software {
+  Install-Chocolatey
+  Install-Pwsh
+  Install-Git
+  Install-Packages curl 7zip
+  Install-NodeJs
+  Install-Bun
+  Install-Cygwin
+  if ($CI) {
+    Install-Tailscale
+    Install-Buildkite
+  }
+}
+
+function Install-Pwsh {
+  Install-Package powershell-core -Command pwsh
+
+  if ($CI) {
+    $shellPath = (Which pwsh -Required)
+    New-ItemProperty `
+      -Path "HKLM:\\SOFTWARE\\OpenSSH" `
+      -Name DefaultShell `
+      -Value $shellPath `
+      -PropertyType String `
+      -Force
+  }
+}
+
+function Install-Git {
+  Install-Packages git
+
+  if ($CI) {
+    Execute-Command git config --system --add safe.directory "*"
+    Execute-Command git config --system core.autocrlf false
+    Execute-Command git config --system core.eol lf
+    Execute-Command git config --system core.longpaths true
+  }
+}
+
+function Install-NodeJs {
+  Install-Package nodejs -Command node -Version "22.9.0"
+}
+
+function Install-Bun {
+  Install-Package bun -Version "1.1.30"
+}
+
+function Install-Cygwin {
+  Install-Package cygwin
+  Add-To-Path "C:\tools\cygwin\bin"
+}
+
+function Install-Tailscale {
+  Install-Package tailscale
+}
+
+function Install-Buildkite {
+  if (Which buildkite-agent) {
+    return
+  }
+
+  Write-Output "Installing Buildkite agent..."
+  $env:buildkiteAgentToken = "xxx"
+  iex ((New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/buildkite/agent/main/install.ps1"))
+  Refresh-Path
+}
+
+function Install-Build-Essentials {
+  # Install-Visual-Studio
+  Install-Packages `
+    cmake `
+    make `
+    ninja `
+    ccache `
+    python `
+    golang `
+    nasm `
+    ruby `
+    mingw
+  Install-Rust
+  Install-Llvm
+}
+
+function Install-Visual-Studio {
+  $components = @(
+    "Microsoft.VisualStudio.Workload.NativeDesktop",
+    "Microsoft.VisualStudio.Component.Windows10SDK.18362",
+    "Microsoft.VisualStudio.Component.Windows11SDK.22000",
+    "Microsoft.VisualStudio.Component.Windows11Sdk.WindowsPerformanceToolkit",
+    "Microsoft.VisualStudio.Component.VC.ASAN", # C++ AddressSanitizer
+    "Microsoft.VisualStudio.Component.VC.ATL", # C++ ATL for latest v143 build tools (x86 & x64)
+    "Microsoft.VisualStudio.Component.VC.DiagnosticTools", # C++ Diagnostic Tools
+    "Microsoft.VisualStudio.Component.VC.CLI.Support", # C++/CLI support for v143 build tools (Latest)
+    "Microsoft.VisualStudio.Component.VC.CoreIde", # C++ core features
+    "Microsoft.VisualStudio.Component.VC.Redist.14.Latest" # C++ 2022 Redistributable Update
+  )
+
+  $arch = (Get-WmiObject Win32_Processor).Architecture
+  if ($arch -eq 9) {
+    $components += @(
+      "Microsoft.VisualStudio.Component.VC.Tools.x86.x64", # MSVC v143 build tools (x86 & x64)
+      "Microsoft.VisualStudio.Component.VC.Modules.x86.x64" # MSVC v143 C++ Modules for latest v143 build tools (x86 & x64)
+    )
+  } elseif ($arch -eq 5) {
+    $components += @(
+      "Microsoft.VisualStudio.Component.VC.Tools.ARM64", # MSVC v143 build tools (ARM64)
+      "Microsoft.VisualStudio.Component.UWP.VC.ARM64" # C++ Universal Windows Platform support for v143 build tools (ARM64/ARM64EC)
+    )
+  }
+
+  $packageParameters = $components | ForEach-Object { "--add $_" }
+  Install-Package visualstudio2022community `
+    -ExtraArgs "--package-parameters '--add Microsoft.VisualStudio.Workload.NativeDesktop --includeRecommended --includeOptional'"
+}
+
+function Install-Rust {
+  if (Which rustc) {
+    return
+  }
+
+  Write-Output "Installing Rust..."
+  $rustupInit = "$env:TEMP\rustup-init.exe"
+  (New-Object System.Net.WebClient).DownloadFile("https://win.rustup.rs/", $rustupInit)
+  Execute-Command $rustupInit -y
+  Add-To-Path "$env:USERPROFILE\.cargo\bin"
+}
+
+function Install-Llvm {
+  Install-Package llvm `
+    -Command clang-cl `
+    -Version "18.1.8"
+  Add-To-Path "C:\Program Files\LLVM\bin"
+}
+
+function Optimize-System {
+  Disable-Windows-Defender
+  Disable-Windows-Threat-Protection
+  Disable-Windows-Services
+  Disable-Power-Management
+  Uninstall-Windows-Defender
+}
+
+function Disable-Windows-Defender {
+  Write-Output "Disabling Windows Defender..."
+  Set-MpPreference -DisableRealtimeMonitoring $true
+  Add-MpPreference -ExclusionPath "C:\", "D:\"
+}
+
+function Disable-Windows-Threat-Protection {
+  $itemPath = "HKLM:\SOFTWARE\Policies\Microsoft\Windows Advanced Threat Protection"
+  if (Test-Path $itemPath) {
+    Write-Output "Disabling Windows Threat Protection..."
+    Set-ItemProperty -Path $itemPath -Name "ForceDefenderPassiveMode" -Value 1 -Type DWORD
+  }
+}
+
+function Uninstall-Windows-Defender {
+  Write-Output "Uninstalling Windows Defender..."
+  Uninstall-WindowsFeature -Name Windows-Defender
+}
+
+function Disable-Windows-Services {
+  $services = @(
+    "WSearch",          # Windows Search
+    "wuauserv",         # Windows Update
+    "DiagTrack",        # Connected User Experiences and Telemetry
+    "dmwappushservice", # WAP Push Message Routing Service
+    "PcaSvc",           # Program Compatibility Assistant
+    "SysMain"           # Superfetch
+  )
+
+  foreach ($service in $services) {
+    Stop-Service $service -Force
+    Set-Service $service -StartupType Disabled
+  }
+}
+
+function Disable-Power-Management {
+  Write-Output "Disabling power management features..."
+  powercfg /setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c # High performance
+  powercfg /change monitor-timeout-ac 0
+  powercfg /change monitor-timeout-dc 0
+  powercfg /change standby-timeout-ac 0
+  powercfg /change standby-timeout-dc 0
+  powercfg /change hibernate-timeout-ac 0
+  powercfg /change hibernate-timeout-dc 0
+}
+
+Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force
+if ($Optimize) {
+  Optimize-System
+}
+
+Install-Common-Software
+Install-Build-Essentials
+
diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh
index e09ef4fb6ceabc..c5f59ca1163d5d 100755
--- a/scripts/bootstrap.sh
+++ b/scripts/bootstrap.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# Version: 5
 
 # A script that installs the dependencies needed to build and test Bun.
 # This should work on macOS and Linux with a POSIX shell.
@@ -7,11 +8,10 @@
 # https://github.com/oven-sh/bun/issues
 
 # If you need to make a change to this script, such as upgrading a dependency,
-# increment the version number to indicate that a new image should be built.
+# increment the version comment to indicate that a new image should be built.
 # Otherwise, the existing image will be retroactively updated.
-v="3"
+
 pid=$$
-script="$(realpath "$0")"
 
 print() {
 	echo "$@"
@@ -24,28 +24,41 @@ error() {
 }
 
 execute() {
-  print "$ $@" >&2
-  if ! "$@"; then
-    error "Command failed: $@"
-  fi
+	print "$ $@" >&2
+	if ! "$@"; then
+		error "Command failed: $@"
+	fi
 }
 
 execute_sudo() {
-	if [ "$sudo" = "1" ]; then
+	if [ "$sudo" = "1" ] || [ -z "$can_sudo" ]; then
 		execute "$@"
 	else
-		execute sudo "$@"
+		execute sudo -n "$@"
 	fi
 }
 
-execute_non_root() {
-	if [ "$sudo" = "1" ]; then
-		execute sudo -u "$user" "$@"
+execute_as_user() {
+	if [ "$sudo" = "1" ] || [ "$can_sudo" = "1" ]; then
+		if [ -f "$(which sudo)" ]; then
+			execute sudo -n -u "$user" /bin/sh -c "$*"
+		elif [ -f "$(which doas)" ]; then
+			execute doas -u "$user" /bin/sh -c "$*"
+		elif [ -f "$(which su)" ]; then
+			execute su -s /bin/sh "$user" -c "$*"
+		else
+			execute /bin/sh -c "$*"
+		fi
 	else
-		execute "$@"
+		execute /bin/sh -c "$*"
 	fi
 }
 
+grant_to_user() {
+	path="$1"
+	execute_sudo chown -R "$user:$group" "$path"
+}
+
 which() {
 	command -v "$1"
 }
@@ -73,12 +86,16 @@ fetch() {
 }
 
 download_file() {
-  url="$1"
-  filename="${2:-$(basename "$url")}"
-  path="$(mktemp -d)/$filename"
+	url="$1"
+	filename="${2:-$(basename "$url")}"
+	tmp="$(execute mktemp -d)"
+	execute chmod 755 "$tmp"
 
-  fetch "$url" > "$path"
-  print "$path"
+	path="$tmp/$filename"
+	fetch "$url" > "$path"
+	execute chmod 644 "$path"
+
+	print "$path"
 }
 
 compare_version() {
@@ -96,13 +113,13 @@ append_to_file() {
 	content="$2"
 
 	if ! [ -f "$file" ]; then
-		execute mkdir -p "$(dirname "$file")"
-		execute touch "$file"
+		execute_as_user mkdir -p "$(dirname "$file")"
+		execute_as_user touch "$file"
 	fi
 
 	echo "$content" | while read -r line; do
 		if ! grep -q "$line" "$file"; then
-			echo "$line" >> "$file"
+			echo "$line" >>"$file"
 		fi
 	done
 }
@@ -111,7 +128,7 @@ append_to_profile() {
 	content="$1"
 	profiles=".profile .zprofile .bash_profile .bashrc .zshrc"
 	for profile in $profiles; do
-		file="$HOME/$profile"
+		file="$home/$profile"
 		if [ "$ci" = "1" ] || [ -f "$file" ]; then
 			append_to_file "$file" "$content"
 		fi
@@ -124,172 +141,265 @@ append_to_path() {
 		error "Could not find directory: \"$path\""
 	fi
 
-	append_to_profile "export PATH=\"\$PATH\":$path"
-	export PATH="$PATH:$path"
+	append_to_profile "export PATH=\"$path:\$PATH\""
+	export PATH="$path:$PATH"
 }
 
-check_system() {
+link_to_bin() {
+	path="$1"
+	if ! [ -d "$path" ]; then
+		error "Could not find directory: \"$path\""
+	fi
+
+	for file in "$path"/*; do
+		if [ -f "$file" ]; then
+			grant_to_user "$file"
+			execute_sudo ln -sf "$file" "/usr/bin/$(basename "$file")"
+		fi
+	done
+}
+
+check_features() {
+	print "Checking features..."
+
+	case "$CI" in
+	true | 1)
+		ci=1
+		print "CI: enabled"
+		;;
+	esac
+
+	case "$@" in
+	*--ci*)
+		ci=1
+		print "CI: enabled"
+		;;
+	esac
+}
+
+check_operating_system() {
+	print "Checking operating system..."
 	uname="$(require uname)"
 
-	os="$($uname -s)"
+	os="$("$uname" -s)"
 	case "$os" in
 	Linux*) os="linux" ;;
 	Darwin*) os="darwin" ;;
 	*) error "Unsupported operating system: $os" ;;
 	esac
+	print "Operating System: $os"
 
-	arch="$($uname -m)"
+	arch="$("$uname" -m)"
 	case "$arch" in
 	x86_64 | x64 | amd64) arch="x64" ;;
 	aarch64 | arm64) arch="aarch64" ;;
 	*) error "Unsupported architecture: $arch" ;;
 	esac
+	print "Architecture: $arch"
 
-	kernel="$(uname -r)"
+	kernel="$("$uname" -r)"
+	print "Kernel: $kernel"
 
-	if [ "$os" = "darwin" ]; then
+	case "$os" in
+	linux)
+		if [ -f "/etc/alpine-release" ]; then
+			distro="alpine"
+			abi="musl"
+			alpine="$(cat /etc/alpine-release)"
+			if [ "$alpine" ~ "_" ]; then
+				release="$(echo "$alpine" | cut -d_ -f1)-edge"
+			else
+				release="$alpine"
+			fi
+		elif [ -f "/etc/os-release" ]; then
+			. /etc/os-release
+			if [ -n "$ID" ]; then
+				distro="$ID"
+			fi
+			if [ -n "$VERSION_ID" ]; then
+				release="$VERSION_ID"
+			fi
+		fi
+		;;
+	darwin)
 		sw_vers="$(which sw_vers)"
 		if [ -f "$sw_vers" ]; then
-			distro="$($sw_vers -productName)"
-			release="$($sw_vers -productVersion)"
+			distro="$("$sw_vers" -productName)"
+			release="$("$sw_vers" -productVersion)"
 		fi
-
-		if [ "$arch" = "x64" ]; then
+		case "$arch" in
+		x64)
 			sysctl="$(which sysctl)"
-			if [ -f "$sysctl" ] && [ "$($sysctl -n sysctl.proc_translated 2>/dev/null)" = "1" ]; then
+			if [ -f "$sysctl" ] && [ "$("$sysctl" -n sysctl.proc_translated 2>/dev/null)" = "1" ]; then
 				arch="aarch64"
 				rosetta="1"
+				print "Rosetta: enabled"
 			fi
-		fi
+			;;
+		esac
+		;;
+	esac
+
+	if [ -n "$distro" ]; then
+		print "Distribution: $distro $release"
 	fi
 
-	if [ "$os" = "linux" ] && [ -f /etc/os-release ]; then
-		. /etc/os-release
-		if [ -n "$ID" ]; then
-			distro="$ID"
+	case "$os" in
+	linux)
+		ldd="$(which ldd)"
+		if [ -f "$ldd" ]; then
+			ldd_version="$($ldd --version 2>&1)"
+			abi_version="$(echo "$ldd_version" | grep -o -E '[0-9]+\.[0-9]+(\.[0-9]+)?' | head -n 1)"
+			case "$ldd_version" in
+			*musl*)
+				abi="musl"
+				;;
+			*GNU* | *GLIBC*)
+				abi="gnu"
+				;;
+			esac
 		fi
-		if [ -n "$VERSION_ID" ]; then
-			release="$VERSION_ID"
 
-			if [ "$distro" = "alpine" ]; then
-				if [ "$(echo $release | grep -c '_')" = "1" ]; then
-					release="edge"
-				fi
-			fi
+		if [ -n "$abi" ]; then
+			print "ABI: $abi $abi_version"
 		fi
+		;;
+	esac
+}
+
+check_inside_docker() {
+	if ! [ "$os" = "linux" ]; then
+		return
 	fi
+	print "Checking if inside Docker..."
 
-	if [ "$os" = "linux" ]; then
-		rpm="$(which rpm)"
-		if [ -f "$rpm" ]; then
-			glibc="$($rpm -q glibc --queryformat '%{VERSION}\n')"
-		else
-			ldd="$(which ldd)"
-			awk="$(which awk)"
-			if [ -f "$ldd" ] && [ -f "$awk" ]; then
-				glibc="$($ldd --version | $awk 'NR==1{print $NF}')"
-			fi
+	if [ -f "/.dockerenv" ]; then
+		docker=1
+	else
+		if [ -f "/proc/1/cgroup" ]; then
+			case "$(cat /proc/1/cgroup)" in
+			*/docker/*)
+				docker=1
+				;;
+			esac
 		fi
-	fi
 
-	if [ "$os" = "darwin" ]; then
-		brew="$(which brew)"
-		pm="brew"
+		if [ -f "/proc/self/mountinfo" ]; then
+			case "$(cat /proc/self/mountinfo)" in
+			*/docker/*)
+				docker=1
+				;;
+			esac
+		fi
 	fi
 
-	if [ "$os" = "linux" ]; then
-		apt="$(which apt-get)"
-		if [ -f "$apt" ]; then
-			pm="apt"
+	if [ "$docker" = "1" ]; then
+		print "Docker: enabled"
+	fi
+}
 
-		else
-			dnf="$(which dnf)"
-			if [ -f "$dnf" ]; then
-				pm="dnf"
+check_package_manager() {
+	print "Checking package manager..."
 
-			else
-        yum="$(which yum)"
-        if [ -f "$yum" ]; then
-          pm="yum"
-
-				else
-					apk="$(which apk)"
-					if [ -f "$apk" ]; then
-						pm="apk"
-					fi
-        fi
-			fi
+	case "$os" in
+	darwin)
+		if ! [ -f "$(which brew)" ]; then
+			install_brew
 		fi
-
-		if [ -z "$pm" ]; then
+		pm="brew"
+		;;
+	linux)
+		if [ -f "$(which apt-get)" ]; then
+			pm="apt"
+		elif [ -f "$(which dnf)" ]; then
+			pm="dnf"
+		elif [ -f "$(which yum)" ]; then
+			pm="yum"
+		elif [ -f "$(which apk)" ]; then
+			pm="apk"
+		else
 			error "No package manager found. (apt, dnf, yum, apk)"
 		fi
-	fi
+		;;
+	esac
+	print "Package manager: $pm"
+
+	print "Updating package manager..."
+	case "$pm" in
+	apt)
+		export DEBIAN_FRONTEND=noninteractive
+		package_manager update -y
+		;;
+	apk)
+		package_manager update
+		;;
+	esac
+}
+
+check_user() {
+	print "Checking user..."
 
 	if [ -n "$SUDO_USER" ]; then
 		user="$SUDO_USER"
 	else
-		whoami="$(which whoami)"
-		if [ -f "$whoami" ]; then
-			user="$($whoami)"
-		else
-			error "Could not determine the current user, set \$USER."
-		fi
+		id="$(require id)"
+		user="$("$id" -un)"
+		group="$("$id" -gn)"
 	fi
-
-	id="$(which id)"
-	if [ -f "$id" ] && [ "$($id -u)" = "0" ]; then
-		sudo=1
+	if [ -z "$user" ]; then
+		error "Could not determine user"
 	fi
+	print "User: $user"
+	print "Group: $group"
 
-	if [ "$CI" = "true" ]; then
-		ci=1
+	home="$(execute_as_user echo '~')"
+	if [ -z "$home" ] || [ "$home" = "~" ]; then
+		error "Could not determine home directory for user: $user"
 	fi
+	print "Home: $home"
 
-	print "System information:"
-	if [ -n "$distro" ]; then
-		print "| Distro: $distro $release"
-	fi
-	print "| Operating system: $os"
-	print "| Architecture: $arch"
-	if [ -n "$rosetta" ]; then
-		print "| Rosetta: true"
-	fi
-	if [ -n "$glibc" ]; then
-		print "| Glibc: $glibc"
-	fi
-	print "| Package manager: $pm"
-	print "| User: $user"
-	if [ -n "$sudo" ]; then
-		print "| Sudo: true"
-	fi
-	if [ -n "$ci" ]; then
-		print "| CI: true"
+	id="$(which id)"
+	if [ -f "$id" ] && [ "$($id -u)" = "0" ]; then
+		sudo=1
+		print "Sudo: enabled"
+	elif [ -f "$(which sudo)" ] && [ "$(sudo -n echo 1 2>/dev/null)" = "1" ]; then
+		can_sudo=1
+		print "Sudo: can be used"
 	fi
 }
 
 package_manager() {
 	case "$pm" in
-	apt) DEBIAN_FRONTEND=noninteractive \
-		execute "$apt" "$@" ;;
-	dnf) execute dnf "$@" ;;
-	yum) execute "$yum" "$@" ;;
+	apt)
+		while ! sudo -n apt-get update -y; do
+			sleep 1
+		done
+		execute_sudo apt-get "$@"
+		;;
+	dnf)
+		case "$distro" in
+		rhel)
+			execute_sudo dnf \
+				--disableplugin=subscription-manager \
+				"$@"
+			;;
+		*)
+			execute_sudo dnf "$@"
+			;;
+		esac
+		;;
+	yum)
+		execute_sudo yum "$@"
+		;;
+	apk)
+		execute_sudo apk "$@"
+		;;
 	brew)
-    if ! [ -f "$brew" ]; then
-      install_brew
-    fi
-    execute_non_root "$brew" "$@"
-    ;;
-	apk) execute "$apk" "$@" ;;
-	*) error "Unsupported package manager: $pm" ;;
-	esac
-}
-
-update_packages() {
-	case "$pm" in
-	apt | apk)
-    package_manager update
-    ;;
+		execute_as_user brew "$@"
+		;;
+	*)
+		error "Unsupported package manager: $pm"
+		;;
 	esac
 }
 
@@ -310,20 +420,38 @@ check_package() {
 install_packages() {
 	case "$pm" in
 	apt)
-		package_manager install --yes --no-install-recommends "$@"
+		package_manager install \
+			--yes \
+			--no-install-recommends \
+			"$@"
 		;;
 	dnf)
-    package_manager install --assumeyes --nodocs --noautoremove --allowerasing "$@"
+		package_manager install \
+			--assumeyes \
+			--nodocs \
+			--noautoremove \
+			--allowerasing \
+			"$@"
 		;;
 	yum)
 		package_manager install -y "$@"
 		;;
 	brew)
-		package_manager install --force --formula "$@"
-    package_manager link --force --overwrite "$@"
+		package_manager install \
+			--force \
+			--formula \
+			"$@"
+		package_manager link \
+			--force \
+			--overwrite \
+			"$@"
 		;;
 	apk)
-		package_manager add "$@"
+		package_manager add \
+			--no-cache \
+			--no-interactive \
+			--no-progress \
+			"$@"
 		;;
 	*)
 		error "Unsupported package manager: $pm"
@@ -331,24 +459,12 @@ install_packages() {
 	esac
 }
 
-get_version() {
-  command="$1"
-  path="$(which "$command")"
-
-  if [ -f "$path" ]; then
-    case "$command" in
-      go | zig) "$path" version ;;
-      *) "$path" --version ;;
-    esac
-  else
-    print "not found"
-  fi
-}
-
 install_brew() {
-  bash="$(require bash)"
-  script=$(download_file "https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh")
-	NONINTERACTIVE=1 execute_non_root "$bash" "$script"
+	print "Installing Homebrew..."
+
+	bash="$(require bash)"
+	script=$(download_file "https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh")
+	NONINTERACTIVE=1 execute_as_user "$bash" "$script"
 
 	case "$arch" in
 	x64)
@@ -370,78 +486,166 @@ install_brew() {
 
 install_common_software() {
 	case "$pm" in
-	apt) install_packages \
-		apt-transport-https \
-		software-properties-common
-    ;;
-	dnf) install_packages \
-		dnf-plugins-core \
-		tar
-    ;;
+	apt)
+		install_packages \
+			apt-transport-https \
+			software-properties-common
+		;;
+	dnf)
+		install_packages \
+			dnf-plugins-core
+		;;
+	esac
+
+	case "$distro" in
+	amzn)
+		install_packages \
+			tar
+		;;
+	rhel)
+		rhel_version="$(execute rpm -E %rhel)"
+		install_packages \
+			"https://dl.fedoraproject.org/pub/epel/epel-release-latest-$rhel_version.noarch.rpm"
+		;;
+	centos)
+		install_packages \
+			epel-release
+		;;
 	esac
 
+	crb="$(which crb)"
+	if [ -f "$crb" ]; then
+		execute "$crb" enable
+	fi
+
 	install_packages \
 		bash \
 		ca-certificates \
 		curl \
-		jq \
 		htop \
 		gnupg \
 		git \
 		unzip \
-		wget \
-		zip
+		wget
 
 	install_rosetta
 	install_nodejs
 	install_bun
+	install_tailscale
+	install_buildkite
 }
 
-install_nodejs() {
-	version="${1:-"22"}"
-
-	if ! [ "$(compare_version "$glibc" "2.27")" = "1" ]; then
-		version="16"
+nodejs_version_exact() {
+	# https://unofficial-builds.nodejs.org/download/release/
+	if ! [ "$abi" = "musl" ] && [ -n "$abi_version" ] && ! [ "$(compare_version "$abi_version" "2.27")" = "1" ]; then
+		print "16.9.1"
+	else
+		print "22.9.0"
 	fi
+}
 
+nodejs_version() {
+	echo "$(nodejs_version_exact)" | cut -d. -f1
+}
+
+install_nodejs() {
 	case "$pm" in
 	dnf | yum)
-    bash="$(require bash)"
-    script=$(download_file "https://rpm.nodesource.com/setup_$version.x")
-    execute "$bash" "$script"
+		bash="$(require bash)"
+		script=$(download_file "https://rpm.nodesource.com/setup_$(nodejs_version).x")
+		execute_sudo "$bash" "$script"
 		;;
 	apt)
-    bash="$(require bash)"
-    script=$(download_file "https://deb.nodesource.com/setup_$version.x")
-    execute "$bash" "$script"
+		bash="$(require bash)"
+		script="$(download_file "https://deb.nodesource.com/setup_$(nodejs_version).x")"
+		execute_sudo "$bash" "$script"
 		;;
 	esac
 
-	install_packages nodejs
+	case "$pm" in
+	apk)
+		install_packages nodejs npm
+		;;
+	*)
+		install_packages nodejs
+		;;
+	esac
+
+	# Some distros do not install the node headers by default.
+	# These are needed for certain FFI tests, such as: `cc.test.ts`
+	case "$distro" in
+	alpine | amzn)
+		install_nodejs_headers
+		;;
+	esac
+}
+
+install_nodejs_headers() {
+	headers_tar="$(download_file "https://nodejs.org/download/release/v$(nodejs_version_exact)/node-v$(nodejs_version_exact)-headers.tar.gz")"
+	headers_dir="$(dirname "$headers_tar")"
+	execute tar -xzf "$headers_tar" -C "$headers_dir"
+	headers_include="$headers_dir/node-v$(nodejs_version_exact)/include"
+	execute_sudo cp -R "$headers_include/" "/usr"
 }
 
 install_bun() {
-	if [ "$os" = "linux" ] && [ "$distro" = "alpine" ] && [ "$arch" = "aarch64" ]; then
-		mkdir -p "$HOME/.bun/bin"
-		wget -O "$HOME/.bun/bin/bun" https://pub-61e0d0e2da4146a099e4545a59a9f0f7.r2.dev/bun-musl-arm64
-		chmod +x "$HOME/.bun/bin/bun"
-		append_to_path "$HOME/.bun/bin"
+	case "$os-$abi" in
+	linux-musl)
+		case "$arch" in
+		x64)
+			exe="$(download_file https://pub-61e0d0e2da4146a099e4545a59a9f0f7.r2.dev/bun-musl-x64)"
+			;;
+		aarch64)
+			exe="$(download_file https://pub-61e0d0e2da4146a099e4545a59a9f0f7.r2.dev/bun-musl-arm64)"
+			;;
+		esac
+		execute chmod +x "$exe"
+		execute mkdir -p "$home/.bun/bin"
+		execute mv "$exe" "$home/.bun/bin/bun"
+		execute ln -fs "$home/.bun/bin/bun" "$home/.bun/bin/bunx"
+		link_to_bin "$home/.bun/bin"
 		return
-	fi
-  bash="$(require bash)"
-  script=$(download_file "https://bun.sh/install")
+		;;
+	esac
+
+	bash="$(require bash)"
+	script=$(download_file "https://bun.sh/install")
 
-  version="${1:-"latest"}"
+	version="${1:-"latest"}"
 	case "$version" in
 	latest)
-    execute "$bash" "$script"
+		execute_as_user "$bash" "$script"
 		;;
 	*)
-    execute "$bash" "$script" -s "$version"
+		execute_as_user "$bash" "$script" -s "$version"
 		;;
 	esac
 
-	append_to_path "$HOME/.bun/bin"
+	link_to_bin "$home/.bun/bin"
+}
+
+install_cmake() {
+	case "$os-$pm" in
+	darwin-* | linux-apk)
+		install_packages cmake
+		;;
+	linux-*)
+		sh="$(require sh)"
+		cmake_version="3.30.5"
+		case "$arch" in
+		x64)
+			url="https://github.com/Kitware/CMake/releases/download/v$cmake_version/cmake-$cmake_version-linux-x86_64.sh"
+			;;
+		aarch64)
+			url="https://github.com/Kitware/CMake/releases/download/v$cmake_version/cmake-$cmake_version-linux-aarch64.sh"
+			;;
+		esac
+		script=$(download_file "$url")
+		execute_sudo "$sh" "$script" \
+			--skip-license \
+			--prefix=/usr
+		;;
+	esac
 }
 
 install_rosetta() {
@@ -459,27 +663,56 @@ install_rosetta() {
 install_build_essentials() {
 	case "$pm" in
 	apt)
-		install_packages build-essential ninja-build xz-utils pkg-config golang
-    ;;
+		install_packages \
+			build-essential \
+			ninja-build \
+			xz-utils \
+			pkg-config \
+			golang
+		;;
 	dnf | yum)
-		install_packages ninja-build gcc-c++ xz pkg-config golang
-    ;;
+		install_packages \
+			gcc-c++ \
+			xz \
+			pkg-config \
+			golang
+		case "$distro" in
+		rhel) ;;
+		*)
+			install_packages ninja-build
+			;;
+		esac
+		;;
 	brew)
-		install_packages ninja pkg-config golang
-    ;;
+		install_packages \
+			ninja \
+			pkg-config \
+			golang
+		;;
 	apk)
-		install_packages musl-dev ninja xz
-    ;;
+		install_packages \
+			build-base \
+			linux-headers \
+			ninja \
+			go \
+			xz
+		;;
+	esac
+
+	case "$distro-$pm" in
+	amzn-dnf)
+		package_manager groupinstall -y "Development Tools"
+		;;
 	esac
 
 	install_packages \
 		make \
-		cmake \
 		python3 \
 		libtool \
 		ruby \
 		perl
 
+	install_cmake
 	install_llvm
 	install_ccache
 	install_rust
@@ -487,185 +720,189 @@ install_build_essentials() {
 }
 
 llvm_version_exact() {
-	if [ "$os" = "linux" ] && [ "$distro" = "alpine" ]; then
+	case "$os-$abi" in
+	darwin-* | windows-* | linux-musl)
 		print "18.1.8"
-		return
-	fi
-  case "$os" in
-  linux)
-    print "16.0.6"
-    ;;
-  darwin | windows)
-    print "18.1.8"
-    ;;
-  esac
+		;;
+	linux-*)
+		print "16.0.6"
+		;;
+	esac
 }
 
 llvm_version() {
-  echo "$(llvm_version_exact)" | cut -d. -f1
+	echo "$(llvm_version_exact)" | cut -d. -f1
 }
 
 install_llvm() {
 	case "$pm" in
 	apt)
-    bash="$(require bash)"
-    script=$(download_file "https://apt.llvm.org/llvm.sh")
-		execute "$bash" "$script" "$(llvm_version)" all
+		bash="$(require bash)"
+		script="$(download_file "https://apt.llvm.org/llvm.sh")"
+		case "$distro-$release" in
+		ubuntu-24*)
+			execute_sudo "$bash" "$script" "$(llvm_version)" all -njammy
+			;;
+		*)
+			execute_sudo "$bash" "$script" "$(llvm_version)" all
+			;;
+		esac
+		;;
+	brew)
+		install_packages "llvm@$(llvm_version)"
+		;;
+	apk)
+		install_packages \
+			"llvm$(llvm_version)" \
+			"clang$(llvm_version)" \
+			"scudo-malloc" \
+			--repository "http://dl-cdn.alpinelinux.org/alpine/edge/main"
+		install_packages \
+			"lld$(llvm_version)" \
+			--repository "http://dl-cdn.alpinelinux.org/alpine/edge/community"
 		;;
-  brew)
-    install_packages "llvm@$(llvm_version)"
-    ;;
-  apk)
-    install_packages "llvm$(llvm_version)-dev" "clang$(llvm_version)-dev" "lld$(llvm_version)-dev"
-		append_to_path "/usr/lib/llvm$(llvm_version)/bin"
-    ;;
 	esac
 }
 
 install_ccache() {
-  case "$pm" in
-  apt | brew)
-    install_packages ccache
-    ;;
-  esac
+	case "$pm" in
+	apt | apk | brew)
+		install_packages ccache
+		;;
+	esac
 }
 
 install_rust() {
-	if [ "$os" = "linux" ] && [ "$distro" = "alpine" ]; then
-		install_packages rust cargo
-		mkdir -p "$HOME/.cargo/bin"
-		append_to_path "$HOME/.cargo/bin"
-		return
-	fi
-  sh="$(require sh)"
-  script=$(download_file "https://sh.rustup.rs")
-  execute "$sh" "$script" -y
-	append_to_path "$HOME/.cargo/bin"
+	case "$pm" in
+	apk)
+		install_packages \
+			rust \
+			cargo
+		;;
+	*)
+		sh="$(require sh)"
+		script=$(download_file "https://sh.rustup.rs")
+		execute_as_user "$sh" "$script" -y
+		;;
+	esac
+
+	# FIXME: This causes cargo to fail to build:
+	# > error: rustup could not choose a version of cargo to run,
+	# > because one wasn't specified explicitly, and no default is configured.
+	# link_to_bin "$home/.cargo/bin"
 }
 
 install_docker() {
 	case "$pm" in
 	brew)
-    if ! [ -d "/Applications/Docker.app" ]; then
-		  package_manager install docker --cask
-    fi
-		;;
-	apk)
-		install_packages docker
+		if ! [ -d "/Applications/Docker.app" ]; then
+			package_manager install docker --cask
+		fi
 		;;
 	*)
-    case "$distro-$release" in
-    amzn-2 | amzn-1)
-      execute amazon-linux-extras install docker
-      ;;
-    amzn-*)
-      install_packages docker
-      ;;
-    *)
-      sh="$(require sh)"
-      script=$(download_file "https://get.docker.com")
-      execute "$sh" "$script"
-		  ;;
-    esac
-    ;;
-	esac
-
-  systemctl="$(which systemctl)"
-  if [ -f "$systemctl" ]; then
-    execute "$systemctl" enable docker
-  fi
-}
-
-install_ci_dependencies() {
-	if ! [ "$ci" = "1" ]; then
-		return
+		case "$distro-$release" in
+		amzn-2 | amzn-1)
+			execute amazon-linux-extras install docker
+			;;
+		amzn-* | alpine-*)
+			install_packages docker
+			;;
+		*)
+			sh="$(require sh)"
+			script=$(download_file "https://get.docker.com")
+			execute "$sh" "$script"
+			;;
+		esac
+		;;
+	esac
+
+	systemctl="$(which systemctl)"
+	if [ -f "$systemctl" ]; then
+		execute_sudo "$systemctl" enable docker
 	fi
 
-	install_tailscale
-	install_buildkite
+	getent="$(which getent)"
+	if [ -n "$("$getent" group docker)" ]; then
+		usermod="$(which usermod)"
+		if [ -f "$usermod" ]; then
+			execute_sudo "$usermod" -aG docker "$user"
+		fi
+	fi
 }
 
 install_tailscale() {
+	if [ "$docker" = "1" ]; then
+		return
+	fi
+
 	case "$os" in
 	linux)
-    sh="$(require sh)"
-    script=$(download_file "https://tailscale.com/install.sh")
-    execute "$sh" "$script"
+		sh="$(require sh)"
+		script=$(download_file "https://tailscale.com/install.sh")
+		execute "$sh" "$script"
 		;;
 	darwin)
 		install_packages go
-		execute_non_root go install tailscale.com/cmd/tailscale{,d}@latest
-		append_to_path "$HOME/go/bin"
+		execute_as_user go install tailscale.com/cmd/tailscale{,d}@latest
+		append_to_path "$home/go/bin"
 		;;
 	esac
 }
 
-install_buildkite() {
-	home_dir="/var/lib/buildkite-agent"
-	config_dir="/etc/buildkite-agent"
-	config_file="$config_dir/buildkite-agent.cfg"
-
-	if ! [ -d "$home_dir" ]; then
-		execute_sudo mkdir -p "$home_dir"
+create_buildkite_user() {
+	if ! [ "$ci" = "1" ] || ! [ "$os" = "linux" ]; then
+		return
 	fi
 
-	if ! [ -d "$config_dir" ]; then
-		execute_sudo mkdir -p "$config_dir"
-	fi
+	print "Creating Buildkite user..."
+	user="buildkite-agent"
+	group="$user"
+	home="/var/lib/buildkite-agent"
 
-	case "$os" in
-	linux)
-		getent="$(require getent)"
-		if [ -z "$("$getent" passwd buildkite-agent)" ]; then
-			useradd="$(require useradd)"
-			execute "$useradd" buildkite-agent \
-				--system \
-				--no-create-home \
-				--home-dir "$home_dir"
-		fi
-
-		if [ -n "$("$getent" group docker)" ]; then
-			usermod="$(require usermod)"
-			execute "$usermod" -aG docker buildkite-agent
-		fi
-
-		execute chown -R buildkite-agent:buildkite-agent "$home_dir"
-		execute chown -R buildkite-agent:buildkite-agent "$config_dir"
-		;;
-	darwin)
-		execute_sudo chown -R "$user:admin" "$home_dir"
-		execute_sudo chown -R "$user:admin" "$config_dir"
+	case "$distro" in
+	amzn)
+		install_packages \
+			shadow-utils \
+			util-linux
 		;;
 	esac
 
-	if ! [ -f "$config_file" ]; then
-		cat <<EOF >"$config_file"
-# This is generated by scripts/bootstrap.sh
-# https://buildkite.com/docs/agent/v3/configuration
+	if [ -z "$(getent passwd "$user")" ]; then
+		execute_sudo useradd "$user" \
+			--system \
+			--no-create-home \
+			--home-dir "$home"
+	fi
 
-name="%hostname-%random"
-tags="v=$v,os=$os,arch=$arch,distro=$distro,release=$release,kernel=$kernel,glibc=$glibc"
+	if [ -n "$(getent group docker)" ]; then
+		execute_sudo usermod -aG docker "$user"
+	fi
 
-build-path="$home_dir/builds"
-git-mirrors-path="$home_dir/git"
-job-log-path="$home_dir/logs"
-plugins-path="$config_dir/plugins"
-hooks-path="$config_dir/hooks"
+	paths="$home /var/cache/buildkite-agent /var/log/buildkite-agent /var/run/buildkite-agent /var/run/buildkite-agent/buildkite-agent.sock"
+	for path in $paths; do
+		execute_sudo mkdir -p "$path"
+		execute_sudo chown -R "$user:$group" "$path"
+	done
+	
+	files="/var/run/buildkite-agent/buildkite-agent.pid"
+	for file in $files; do
+		execute_sudo touch "$file"
+		execute_sudo chown "$user:$group" "$file"
+	done
+}
 
-no-ssh-keyscan=true
-cancel-grace-period=3600000 # 1 hour
-enable-job-log-tmpfile=true
-experiment="normalised-upload-paths,resolve-commit-after-checkout,agent-api"
-EOF
+install_buildkite() {
+	if ! [ "$ci" = "1" ]; then
+		return
 	fi
 
 	bash="$(require bash)"
-	script=$(download_file "https://raw.githubusercontent.com/buildkite/agent/main/install.sh")
-	execute "$bash" "$script"
+	script="$(download_file "https://raw.githubusercontent.com/buildkite/agent/main/install.sh")"
+	tmp_dir="$(execute dirname "$script")"
+	HOME="$tmp_dir" execute "$bash" "$script"
 
-	out_dir="$HOME/.buildkite-agent"
-	execute_sudo mv -f "$out_dir/bin/buildkite-agent" "/usr/local/bin/buildkite-agent"
-	execute rm -rf "$out_dir"
+	out_dir="$tmp_dir/.buildkite-agent"
+	execute_sudo mv -f "$out_dir/bin/buildkite-agent" "/usr/bin/buildkite-agent"
 }
 
 install_chrome_dependencies() {
@@ -738,19 +975,26 @@ install_chrome_dependencies() {
 			xorg-x11-fonts-Type1 \
 			xorg-x11-utils
 		;;
-	apk)
-		echo # TODO:
+	esac
+
+	case "$distro" in
+	amzn)
+		install_packages \
+			mesa-libgbm
 		;;
 	esac
 }
 
 main() {
-  check_system
-  update_packages
-  install_common_software
-  install_build_essentials
-  install_chrome_dependencies
-  install_ci_dependencies
-}
-
-main
+	check_features "$@"
+	check_operating_system
+	check_inside_docker
+	check_user
+	check_package_manager
+	create_buildkite_user
+	install_common_software
+	install_build_essentials
+	install_chrome_dependencies
+}
+
+main "$@"
diff --git a/scripts/build.mjs b/scripts/build.mjs
old mode 100644
new mode 100755
diff --git a/scripts/features.mjs b/scripts/features.mjs
old mode 100644
new mode 100755
diff --git a/scripts/machine.mjs b/scripts/machine.mjs
new file mode 100755
index 00000000000000..1048d6abff98f3
--- /dev/null
+++ b/scripts/machine.mjs
@@ -0,0 +1,1305 @@
+#!/usr/bin/env node
+
+import { inspect, parseArgs } from "node:util";
+import {
+  $,
+  getBootstrapVersion,
+  getBuildNumber,
+  getSecret,
+  isCI,
+  parseArch,
+  parseOs,
+  readFile,
+  spawn,
+  spawnSafe,
+  spawnSyncSafe,
+  startGroup,
+  tmpdir,
+  waitForPort,
+  which,
+  escapePowershell,
+} from "./utils.mjs";
+import { join, relative, resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const docker = {
+  getPlatform(platform) {
+    const { os, arch } = platform;
+
+    if (os === "linux" || os === "windows") {
+      if (arch === "aarch64") {
+        return `${os}/arm64`;
+      } else if (arch === "x64") {
+        return `${os}/amd64`;
+      }
+    }
+
+    throw new Error(`Unsupported platform: ${inspect(platform)}`);
+  },
+
+  async createMachine(platform) {
+    const { id } = await docker.getImage(platform);
+    const platformString = docker.getPlatform(platform);
+
+    const command = ["sleep", "1d"];
+    const { stdout } = await spawnSafe(["docker", "run", "--rm", "--platform", platformString, "-d", id, ...command]);
+    const containerId = stdout.trim();
+
+    const spawn = async command => {
+      return spawn(["docker", "exec", containerId, ...command]);
+    };
+
+    const spawnSafe = async command => {
+      return spawnSafe(["docker", "exec", containerId, ...command]);
+    };
+
+    const attach = async () => {
+      const { exitCode, spawnError } = await spawn(["docker", "exec", "-it", containerId, "bash"], {
+        stdio: "inherit",
+      });
+
+      if (exitCode === 0 || exitCode === 130) {
+        return;
+      }
+
+      throw spawnError;
+    };
+
+    const kill = async () => {
+      await spawnSafe(["docker", "kill", containerId]);
+    };
+
+    return {
+      spawn,
+      spawnSafe,
+      attach,
+      close: kill,
+      [Symbol.asyncDispose]: kill,
+    };
+  },
+
+  async getImage(platform) {
+    const os = platform["os"];
+    const distro = platform["distro"];
+    const release = platform["release"] || "latest";
+
+    let url;
+    if (os === "linux") {
+      if (distro === "debian") {
+        url = `docker.io/library/debian:${release}`;
+      } else if (distro === "ubuntu") {
+        url = `docker.io/library/ubuntu:${release}`;
+      } else if (distro === "amazonlinux") {
+        url = `public.ecr.aws/amazonlinux/amazonlinux:${release}`;
+      } else if (distro === "alpine") {
+        url = `docker.io/library/alpine:${release}`;
+      }
+    }
+
+    if (url) {
+      await spawnSafe(["docker", "pull", "--platform", docker.getPlatform(platform), url]);
+      const { stdout } = await spawnSafe(["docker", "image", "inspect", url, "--format", "json"]);
+      const [{ Id }] = JSON.parse(stdout);
+      return {
+        id: Id,
+        name: url,
+        username: "root",
+      };
+    }
+
+    throw new Error(`Unsupported platform: ${inspect(platform)}`);
+  },
+};
+
+export const aws = {
+  get name() {
+    return "aws";
+  },
+
+  /**
+   * @param {string[]} args
+   * @returns {Promise<unknown>}
+   */
+  async spawn(args) {
+    const aws = which("aws");
+    if (!aws) {
+      throw new Error("AWS CLI is not installed, please install it");
+    }
+
+    let env;
+    if (isCI) {
+      env = {
+        AWS_ACCESS_KEY_ID: getSecret("EC2_ACCESS_KEY_ID", { required: true }),
+        AWS_SECRET_ACCESS_KEY: getSecret("EC2_SECRET_ACCESS_KEY", { required: true }),
+        AWS_REGION: getSecret("EC2_REGION", { required: false }) || "us-east-1",
+      };
+    }
+
+    const { error, stdout } = await spawn($`${aws} ${args} --output json`, { env });
+    if (error) {
+      if (/max attempts exceeded/i.test(inspect(error))) {
+        return this.spawn(args);
+      }
+      throw error;
+    }
+
+    try {
+      return JSON.parse(stdout);
+    } catch {
+      return;
+    }
+  },
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {string[]}
+   */
+  getFilters(options = {}) {
+    return Object.entries(options)
+      .filter(([_, value]) => typeof value !== "undefined")
+      .map(([key, value]) => `Name=${key},Values=${value}`);
+  },
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {string[]}
+   */
+  getFlags(options = {}) {
+    return Object.entries(options)
+      .filter(([_, value]) => typeof value !== "undefined")
+      .map(([key, value]) => `--${key}=${value}`);
+  },
+
+  /**
+   * @typedef AwsInstance
+   * @property {string} InstanceId
+   * @property {string} ImageId
+   * @property {string} InstanceType
+   * @property {string} [PublicIpAddress]
+   * @property {string} [PlatformDetails]
+   * @property {string} [Architecture]
+   * @property {object} [Placement]
+   * @property {string} [Placement.AvailabilityZone]
+   * @property {string} LaunchTime
+   */
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {Promise<AwsInstance[]>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-instances.html
+   */
+  async describeInstances(options) {
+    const filters = aws.getFilters(options);
+    const { Reservations } = await aws.spawn($`ec2 describe-instances --filters ${filters}`);
+    return Reservations.flatMap(({ Instances }) => Instances).sort((a, b) => (a.LaunchTime < b.LaunchTime ? 1 : -1));
+  },
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {Promise<AwsInstance[]>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/run-instances.html
+   */
+  async runInstances(options) {
+    const flags = aws.getFlags(options);
+    const { Instances } = await aws.spawn($`ec2 run-instances ${flags}`);
+    return Instances.sort((a, b) => (a.LaunchTime < b.LaunchTime ? 1 : -1));
+  },
+
+  /**
+   * @param {...string} instanceIds
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/stop-instances.html
+   */
+  async stopInstances(...instanceIds) {
+    await aws.spawn($`ec2 stop-instances --no-hibernate --force --instance-ids ${instanceIds}`);
+  },
+
+  /**
+   * @param {...string} instanceIds
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/terminate-instances.html
+   */
+  async terminateInstances(...instanceIds) {
+    await aws.spawn($`ec2 terminate-instances --instance-ids ${instanceIds}`);
+  },
+
+  /**
+   * @param {"instance-running" | "instance-stopped" | "instance-terminated"} action
+   * @param {...string} instanceIds
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/wait.html
+   */
+  async waitInstances(action, ...instanceIds) {
+    await aws.spawn($`ec2 wait ${action} --instance-ids ${instanceIds}`);
+  },
+
+  /**
+   * @typedef AwsImage
+   * @property {string} ImageId
+   * @property {string} Name
+   * @property {string} State
+   * @property {string} CreationDate
+   */
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {Promise<AwsImage[]>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-images.html
+   */
+  async describeImages(options = {}) {
+    const { ["owner-alias"]: owners, ...filterOptions } = options;
+    const filters = aws.getFilters(filterOptions);
+    if (owners) {
+      filters.push(`--owners=${owners}`);
+    }
+    const { Images } = await aws.spawn($`ec2 describe-images --filters ${filters}`);
+    return Images.sort((a, b) => (a.CreationDate < b.CreationDate ? 1 : -1));
+  },
+
+  /**
+   * @param {Record<string, string | undefined>} [options]
+   * @returns {Promise<string>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-image.html
+   */
+  async createImage(options) {
+    const flags = aws.getFlags(options);
+    try {
+      const { ImageId } = await aws.spawn($`ec2 create-image ${flags}`);
+      return ImageId;
+    } catch (error) {
+      const match = /already in use by AMI (ami-[a-z0-9]+)/i.exec(inspect(error));
+      if (!match) {
+        throw error;
+      }
+      const [, existingImageId] = match;
+      await aws.spawn($`ec2 deregister-image --image-id ${existingImageId}`);
+      const { ImageId } = await aws.spawn($`ec2 create-image ${flags}`);
+      return ImageId;
+    }
+  },
+
+  /**
+   * @param {Record<string, string | undefined>} options
+   * @returns {Promise<string>}
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/copy-image.html
+   */
+  async copyImage(options) {
+    const flags = aws.getFlags(options);
+    const { ImageId } = await aws.spawn($`ec2 copy-image ${flags}`);
+    return ImageId;
+  },
+
+  /**
+   * @param {"image-available"} action
+   * @param {...string} imageIds
+   * @link https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/wait/image-available.html
+   */
+  async waitImage(action, ...imageIds) {
+    await aws.spawn($`ec2 wait ${action} --image-ids ${imageIds}`);
+  },
+
+  /**
+   * @param {AwsImage | string} imageOrImageId
+   * @returns {Promise<AwsImage>}
+   */
+  async getAvailableImage(imageOrImageId) {
+    let imageId = imageOrImageId;
+    if (typeof imageOrImageId === "object") {
+      const { ImageId, State } = imageOrImageId;
+      if (State === "available") {
+        return imageOrImageId;
+      }
+      imageId = ImageId;
+    }
+
+    await aws.waitImage("image-available", imageId);
+    const [availableImage] = await aws.describeImages({
+      "state": "available",
+      "image-id": imageId,
+    });
+
+    if (!availableImage) {
+      throw new Error(`Failed to find available image: ${imageId}`);
+    }
+
+    return availableImage;
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<AwsImage>}
+   */
+  async getBaseImage(options) {
+    const { os, arch, distro, distroVersion } = options;
+
+    let name, owner;
+    if (os === "linux") {
+      if (!distro || distro === "debian") {
+        owner = "amazon";
+        name = `debian-${distroVersion || "*"}-${arch === "aarch64" ? "arm64" : "amd64"}-*`;
+      } else if (distro === "ubuntu") {
+        owner = "099720109477";
+        name = `ubuntu/images/hvm-ssd*/ubuntu-*-${distroVersion || "*"}-${arch === "aarch64" ? "arm64" : "amd64"}-server-*`;
+      } else if (distro === "amazonlinux") {
+        owner = "amazon";
+        if (distroVersion === "1") {
+          // EOL
+        } else if (distroVersion === "2") {
+          name = `amzn2-ami-hvm-*-${arch === "aarch64" ? "arm64" : "x86_64"}-gp2`;
+        } else {
+          name = `al${distroVersion || "*"}-ami-*-${arch === "aarch64" ? "arm64" : "x86_64"}`;
+        }
+      } else if (distro === "alpine") {
+        owner = "538276064493";
+        name = `alpine-${distroVersion || "*"}.*-${arch === "aarch64" ? "aarch64" : "x86_64"}-uefi-cloudinit-*`;
+      } else if (distro === "centos") {
+        owner = "aws-marketplace";
+        name = `CentOS-Stream-ec2-${distroVersion || "*"}-*.${arch === "aarch64" ? "aarch64" : "x86_64"}-*`;
+      }
+    } else if (os === "windows") {
+      if (!distro || distro === "server") {
+        owner = "amazon";
+        name = `Windows_Server-${distroVersion || "*"}-English-Full-Base-*`;
+      }
+    }
+
+    if (!name) {
+      throw new Error(`Unsupported platform: ${inspect(options)}`);
+    }
+
+    const baseImages = await aws.describeImages({
+      "state": "available",
+      "owner-alias": owner,
+      "name": name,
+    });
+
+    if (!baseImages.length) {
+      throw new Error(`No base image found: ${inspect(options)}`);
+    }
+
+    const [baseImage] = baseImages;
+    return aws.getAvailableImage(baseImage);
+  },
+
+  /**
+   * @param {MachineOptions} options
+   * @returns {Promise<Machine>}
+   */
+  async createMachine(options) {
+    const { os, arch, imageId, instanceType, tags } = options;
+
+    /** @type {AwsImage} */
+    let image;
+    if (imageId) {
+      image = await aws.getAvailableImage(imageId);
+    } else {
+      image = await aws.getBaseImage(options);
+    }
+
+    const { ImageId, Name, RootDeviceName, BlockDeviceMappings } = image;
+    const blockDeviceMappings = BlockDeviceMappings.map(device => {
+      const { DeviceName } = device;
+      if (DeviceName === RootDeviceName) {
+        return {
+          ...device,
+          Ebs: {
+            VolumeSize: getDiskSize(options),
+          },
+        };
+      }
+      return device;
+    });
+
+    const username = getUsername(Name);
+
+    let userData = getUserData({ ...options, username });
+    if (os === "windows") {
+      userData = `<powershell>${userData}</powershell><powershellArguments>-ExecutionPolicy Unrestricted -NoProfile -NonInteractive</powershellArguments><persist>false</persist>`;
+    }
+
+    let tagSpecification = [];
+    if (tags) {
+      tagSpecification = ["instance", "volume"].map(resourceType => {
+        return {
+          ResourceType: resourceType,
+          Tags: Object.entries(tags).map(([Key, Value]) => ({ Key, Value: String(Value) })),
+        };
+      });
+    }
+
+    const [instance] = await aws.runInstances({
+      ["image-id"]: ImageId,
+      ["instance-type"]: instanceType || (arch === "aarch64" ? "t4g.large" : "t3.large"),
+      ["user-data"]: userData,
+      ["block-device-mappings"]: JSON.stringify(blockDeviceMappings),
+      ["metadata-options"]: JSON.stringify({
+        "HttpTokens": "optional",
+        "HttpEndpoint": "enabled",
+        "HttpProtocolIpv6": "enabled",
+        "InstanceMetadataTags": "enabled",
+      }),
+      ["tag-specifications"]: JSON.stringify(tagSpecification),
+      ["key-name"]: "ashcon-bun",
+    });
+
+    return aws.toMachine(instance, { ...options, username });
+  },
+
+  /**
+   * @param {AwsInstance} instance
+   * @param {MachineOptions} [options]
+   * @returns {Machine}
+   */
+  toMachine(instance, options = {}) {
+    let { InstanceId, ImageId, InstanceType, Placement, PublicIpAddress } = instance;
+
+    const connect = async () => {
+      if (!PublicIpAddress) {
+        await aws.waitInstances("instance-running", InstanceId);
+        const [{ PublicIpAddress: IpAddress }] = await aws.describeInstances({
+          ["instance-id"]: InstanceId,
+        });
+        PublicIpAddress = IpAddress;
+      }
+
+      const { username, sshKeys } = options;
+      const identityPaths = sshKeys
+        ?.filter(({ privatePath }) => existsSync(privatePath))
+        ?.map(({ privatePath }) => privatePath);
+
+      return { hostname: PublicIpAddress, username, identityPaths };
+    };
+
+    const spawn = async (command, options) => {
+      const connectOptions = await connect();
+      return spawnSsh({ ...connectOptions, command }, options);
+    };
+
+    const spawnSafe = async (command, options) => {
+      const connectOptions = await connect();
+      return spawnSshSafe({ ...connectOptions, command }, options);
+    };
+
+    const attach = async () => {
+      const connectOptions = await connect();
+      await spawnSshSafe({ ...connectOptions });
+    };
+
+    const upload = async (source, destination) => {
+      const connectOptions = await connect();
+      await spawnScp({ ...connectOptions, source, destination });
+    };
+
+    const snapshot = async name => {
+      await aws.stopInstances(InstanceId);
+      await aws.waitInstances("instance-stopped", InstanceId);
+      const imageId = await aws.createImage({
+        ["instance-id"]: InstanceId,
+        ["name"]: name || `${InstanceId}-snapshot-${Date.now()}`,
+      });
+      await aws.waitImage("image-available", imageId);
+      return imageId;
+    };
+
+    const terminate = async () => {
+      await aws.terminateInstances(InstanceId);
+    };
+
+    return {
+      cloud: "aws",
+      id: InstanceId,
+      imageId: ImageId,
+      instanceType: InstanceType,
+      region: Placement?.AvailabilityZone,
+      get publicIp() {
+        return PublicIpAddress;
+      },
+      spawn,
+      spawnSafe,
+      upload,
+      attach,
+      snapshot,
+      close: terminate,
+      [Symbol.asyncDispose]: terminate,
+    };
+  },
+};
+
+const google = {
+  async createMachine(platform) {
+    const image = await google.getImage(platform);
+    const { id: imageId, username } = image;
+
+    const authorizedKeys = await getAuthorizedKeys();
+    const sshKeys = authorizedKeys?.map(key => `${username}:${key}`).join("\n") ?? "";
+
+    const { os, ["instance-type"]: type } = platform;
+    const instanceType = type || "e2-standard-4";
+
+    let metadata = `ssh-keys=${sshKeys}`;
+    if (os === "windows") {
+      metadata += `,sysprep-specialize-script-cmd=googet -noconfirm=true install google-compute-engine-ssh,enable-windows-ssh=TRUE`;
+    }
+
+    const [{ id, networkInterfaces }] = await google.createInstances({
+      ["zone"]: "us-central1-a",
+      ["image"]: imageId,
+      ["machine-type"]: instanceType,
+      ["boot-disk-auto-delete"]: true,
+      // ["boot-disk-size"]: "10GB",
+      // ["boot-disk-type"]: "pd-standard",
+      ["metadata"]: metadata,
+    });
+
+    const publicIp = () => {
+      for (const { accessConfigs } of networkInterfaces) {
+        for (const { natIP } of accessConfigs) {
+          return natIP;
+        }
+      }
+      throw new Error(`Failed to find public IP for instance: ${id}`);
+    };
+
+    const spawn = command => {
+      const hostname = publicIp();
+      return spawnSsh({ hostname, username, command });
+    };
+
+    const spawnSafe = command => {
+      const hostname = publicIp();
+      return spawnSshSafe({ hostname, username, command });
+    };
+
+    const attach = async () => {
+      const hostname = publicIp();
+      await spawnSshSafe({ hostname, username });
+    };
+
+    const terminate = async () => {
+      await google.deleteInstance(id);
+    };
+
+    return {
+      spawn,
+      spawnSafe,
+      attach,
+      close: terminate,
+      [Symbol.asyncDispose]: terminate,
+    };
+  },
+
+  async getImage(platform) {
+    const { os, arch, distro, release } = platform;
+    const architecture = arch === "aarch64" ? "ARM64" : "X86_64";
+
+    let name;
+    let username;
+    if (os === "linux") {
+      if (distro === "debian") {
+        name = `debian-${release}-*`;
+        username = "admin";
+      } else if (distro === "ubuntu") {
+        name = `ubuntu-${release.replace(/\./g, "")}-*`;
+        username = "ubuntu";
+      }
+    } else if (os === "windows" && arch === "x64") {
+      if (distro === "server") {
+        name = `windows-server-${release}-dc-core-*`;
+        username = "administrator";
+      }
+    }
+
+    if (name && username) {
+      const images = await google.listImages({ name, architecture });
+      if (images.length) {
+        const [image] = images;
+        const { name, selfLink } = image;
+        return {
+          id: selfLink,
+          name,
+          username,
+        };
+      }
+    }
+
+    throw new Error(`Unsupported platform: ${inspect(platform)}`);
+  },
+
+  async listImages(options = {}) {
+    const filter = Object.entries(options)
+      .map(([key, value]) => [value.includes("*") ? `${key}~${value}` : `${key}=${value}`])
+      .join(" AND ");
+    const filters = filter ? ["--filter", filter] : [];
+    const { stdout } = await spawnSafe(["gcloud", "compute", "images", "list", ...filters, "--format", "json"]);
+    const images = JSON.parse(stdout);
+    return images.sort((a, b) => (a.creationTimestamp < b.creationTimestamp ? 1 : -1));
+  },
+
+  async listInstances(options = {}) {
+    const filter = Object.entries(options)
+      .map(([key, value]) => [value.includes("*") ? `${key}~${value}` : `${key}=${value}`])
+      .join(" AND ");
+    const filters = filter ? ["--filter", filter] : [];
+    const { stdout } = await spawnSafe(["gcloud", "compute", "instances", "list", ...filters, "--format", "json"]);
+    const instances = JSON.parse(stdout);
+    return instances.sort((a, b) => (a.creationTimestamp < b.creationTimestamp ? 1 : -1));
+  },
+
+  async createInstances(options = {}) {
+    const flags = Object.entries(options).flatMap(([key, value]) =>
+      typeof value === "boolean" ? `--${key}` : `--${key}=${value}`,
+    );
+    const randomId = "i-" + Math.random().toString(36).substring(2, 15);
+    const { stdout } = await spawnSafe([
+      "gcloud",
+      "compute",
+      "instances",
+      "create",
+      randomId,
+      ...flags,
+      "--format",
+      "json",
+    ]);
+    const instances = JSON.parse(stdout);
+    return instances.sort((a, b) => (a.creationTimestamp < b.creationTimestamp ? 1 : -1));
+  },
+
+  async deleteInstance(instanceId) {
+    await spawnSafe(["gcloud", "compute", "instances", "delete", instanceId, "--zone", "us-central1-a", "--quiet"]);
+  },
+};
+
+/**
+ * @typedef CloudInit
+ * @property {string} [distro]
+ * @property {SshKey[]} [sshKeys]
+ * @property {string} [username]
+ * @property {string} [password]
+ */
+
+function getUserData(cloudInit) {
+  const { os } = cloudInit;
+  if (os === "windows") {
+    return getWindowsStartupScript(cloudInit);
+  }
+  return getCloudInit(cloudInit);
+}
+
+/**
+ * @param {CloudInit} cloudInit
+ * @returns {string}
+ */
+function getCloudInit(cloudInit) {
+  const username = cloudInit["username"] || "root";
+  const password = cloudInit["password"] || crypto.randomUUID();
+  const authorizedKeys = JSON.stringify(cloudInit["sshKeys"]?.map(({ publicKey }) => publicKey) || []);
+
+  let sftpPath = "/usr/lib/openssh/sftp-server";
+  switch (cloudInit["distro"]) {
+    case "alpine":
+      sftpPath = "/usr/lib/ssh/sftp-server";
+      break;
+    case "amazonlinux":
+    case "rhel":
+    case "centos":
+      sftpPath = "/usr/libexec/openssh/sftp-server";
+      break;
+  }
+
+  // https://cloudinit.readthedocs.io/en/stable/
+  return `#cloud-config
+
+    package_update: true
+    packages:
+      - curl
+      - ca-certificates
+      - openssh-server
+    
+    write_files:
+      - path: /etc/ssh/sshd_config
+        content: |
+          PermitRootLogin yes
+          PasswordAuthentication yes
+          Subsystem sftp ${sftpPath}
+
+    chpasswd:
+      expire: false
+      list: |
+        root:${password}
+        ${username}:${password}
+
+    disable_root: false
+
+    ssh_pwauth: true
+    ssh_authorized_keys: ${authorizedKeys}
+  `;
+}
+
+/**
+ * @param {CloudInit} cloudInit
+ * @returns {string}
+ */
+function getWindowsStartupScript(cloudInit) {
+  const { sshKeys } = cloudInit;
+  const authorizedKeys = sshKeys.filter(({ publicKey }) => publicKey).map(({ publicKey }) => publicKey);
+
+  return `
+    $ErrorActionPreference = "Stop"
+    Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force
+
+    function Install-Ssh {
+      $sshService = Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH.Server*'
+      if ($sshService.State -ne "Installed") {
+        Write-Output "Installing OpenSSH server..."
+        Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
+      }
+
+      $pwshPath = Get-Command pwsh -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Path
+      if (-not $pwshPath) {
+        $pwshPath = Get-Command powershell -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Path
+      }
+
+      if (-not (Get-Service -Name sshd -ErrorAction SilentlyContinue)) {
+        Write-Output "Enabling OpenSSH server..."
+        Set-Service -Name sshd -StartupType Automatic
+        Start-Service sshd
+      }
+
+      if ($pwshPath) {
+        Write-Output "Setting default shell to $pwshPath..."
+        New-ItemProperty -Path "HKLM:\\SOFTWARE\\OpenSSH" -Name DefaultShell -Value $pwshPath -PropertyType String -Force
+      }
+
+      $firewallRule = Get-NetFirewallRule -Name "OpenSSH-Server-In-TCP" -ErrorAction SilentlyContinue
+      if (-not $firewallRule) {
+        Write-Output "Configuring firewall..."
+        New-NetFirewallRule -Name 'OpenSSH-Server-In-TCP' -DisplayName 'OpenSSH Server (sshd)' -Enabled True -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22
+      }
+
+      $sshPath = "C:\\ProgramData\\ssh"
+      if (-not (Test-Path $sshPath)) {
+        Write-Output "Creating SSH directory..."
+        New-Item -Path $sshPath -ItemType Directory
+      }
+
+      $authorizedKeysPath = Join-Path $sshPath "administrators_authorized_keys"
+      $authorizedKeys = @(${authorizedKeys.map(key => `"${escapePowershell(key)}"`).join("\n")})
+      if (-not (Test-Path $authorizedKeysPath) -or (Get-Content $authorizedKeysPath) -ne $authorizedKeys) {
+        Write-Output "Adding SSH keys..."
+        Set-Content -Path $authorizedKeysPath -Value $authorizedKeys
+      }
+
+      $sshdConfigPath = Join-Path $sshPath "sshd_config"
+      $sshdConfig = @"
+        PasswordAuthentication no
+        PubkeyAuthentication yes
+        AuthorizedKeysFile $authorizedKeysPath
+        Subsystem sftp sftp-server.exe
+"@
+      if (-not (Test-Path $sshdConfigPath) -or (Get-Content $sshdConfigPath) -ne $sshdConfig) {
+        Write-Output "Writing SSH configuration..."
+        Set-Content -Path $sshdConfigPath -Value $sshdConfig
+      }
+
+      Write-Output "Restarting SSH server..."
+      Restart-Service sshd
+    }
+
+    Install-Ssh
+  `;
+}
+
+/**
+ * @param {string} distro
+ * @returns {string}
+ */
+function getUsername(distro) {
+  if (/windows/i.test(distro)) {
+    return "administrator";
+  }
+
+  if (/alpine|centos/i.test(distro)) {
+    return "root";
+  }
+
+  if (/debian/i.test(distro)) {
+    return "admin";
+  }
+
+  if (/ubuntu/i.test(distro)) {
+    return "ubuntu";
+  }
+
+  if (/amazon|amzn|al\d+|rhel/i.test(distro)) {
+    return "ec2-user";
+  }
+
+  throw new Error(`Unsupported distro: ${distro}`);
+}
+
+/**
+ * @param {MachineOptions} options
+ * @returns {number}
+ */
+function getDiskSize(options) {
+  const { os, diskSizeGb } = options;
+
+  if (diskSizeGb) {
+    return diskSizeGb;
+  }
+
+  return os === "windows" ? 50 : 30;
+}
+
+/**
+ * @typedef SshKey
+ * @property {string} privatePath
+ * @property {string} publicPath
+ * @property {string} publicKey
+ */
+
+/**
+ * @returns {SshKey}
+ */
+function createSshKey() {
+  const sshPath = join(homedir(), ".ssh");
+  if (!existsSync(sshPath)) {
+    mkdirSync(sshPath, { recursive: true });
+  }
+
+  const name = `id_rsa_${crypto.randomUUID()}`;
+  const privatePath = join(sshPath, name);
+  const publicPath = join(sshPath, `${name}.pub`);
+  spawnSyncSafe(["ssh-keygen", "-t", "rsa", "-b", "4096", "-f", privatePath, "-N", ""], { stdio: "inherit" });
+
+  if (!existsSync(privatePath) || !existsSync(publicPath)) {
+    throw new Error(`Failed to generate SSH key: ${privatePath} / ${publicPath}`);
+  }
+
+  const sshAgent = which("ssh-agent");
+  const sshAdd = which("ssh-add");
+  if (sshAgent && sshAdd) {
+    spawnSyncSafe(["sh", "-c", `eval $(${sshAgent} -s) && ${sshAdd} ${privatePath}`], { stdio: "inherit" });
+  }
+
+  return {
+    privatePath,
+    publicPath,
+    get publicKey() {
+      return readFile(publicPath, { cache: true });
+    },
+  };
+}
+
+/**
+ * @returns {SshKey[]}
+ */
+function getSshKeys() {
+  const homePath = homedir();
+  const sshPath = join(homePath, ".ssh");
+
+  /** @type {SshKey[]} */
+  const sshKeys = [];
+  if (existsSync(sshPath)) {
+    const sshFiles = readdirSync(sshPath, { withFileTypes: true });
+    const publicPaths = sshFiles
+      .filter(entry => entry.isFile() && entry.name.endsWith(".pub"))
+      .map(({ name }) => join(sshPath, name));
+
+    sshKeys.push(
+      ...publicPaths.map(publicPath => ({
+        publicPath,
+        privatePath: publicPath.replace(/\.pub$/, ""),
+        get publicKey() {
+          return readFile(publicPath, { cache: true }).trim();
+        },
+      })),
+    );
+  }
+
+  if (!sshKeys.length) {
+    sshKeys.push(createSshKey());
+  }
+
+  return sshKeys;
+}
+
+/**
+ * @typedef SshOptions
+ * @property {string} hostname
+ * @property {number} [port]
+ * @property {string} [username]
+ * @property {string[]} [command]
+ * @property {string[]} [identityPaths]
+ * @property {number} [retries]
+ */
+
+/**
+ * @param {SshOptions} options
+ * @param {object} [spawnOptions]
+ * @returns {Promise<import("./utils.mjs").SpawnResult>}
+ */
+async function spawnSsh(options, spawnOptions = {}) {
+  const { hostname, port, username, identityPaths, command } = options;
+  await waitForPort({ hostname, port: port || 22 });
+
+  const ssh = ["ssh", hostname, "-o", "StrictHostKeyChecking=no", "-o", "BatchMode=yes"];
+  if (port) {
+    ssh.push("-p", port);
+  }
+  if (username) {
+    ssh.push("-l", username);
+  }
+  if (identityPaths) {
+    ssh.push(...identityPaths.flatMap(path => ["-i", path]));
+  }
+  const stdio = command ? "pipe" : "inherit";
+  if (command) {
+    ssh.push(...command);
+  }
+
+  return spawn(ssh, { stdio, ...spawnOptions });
+}
+
+/**
+ * @param {SshOptions} options
+ * @param {object} [spawnOptions]
+ * @returns {Promise<import("./utils.mjs").SpawnResult>}
+ */
+async function spawnSshSafe(options, spawnOptions = {}) {
+  const { hostname, port, username, identityPaths, command } = options;
+  await waitForPort({ hostname, port: port || 22 });
+
+  const ssh = ["ssh", hostname, "-o", "StrictHostKeyChecking=no", "-o", "BatchMode=yes"];
+  if (port) {
+    ssh.push("-p", port);
+  }
+  if (username) {
+    ssh.push("-l", username);
+  }
+  if (identityPaths) {
+    ssh.push(...identityPaths.flatMap(path => ["-i", path]));
+  }
+  const stdio = command ? "pipe" : "inherit";
+  if (command) {
+    ssh.push(...command);
+  }
+
+  return spawnSafe(ssh, { stdio, ...spawnOptions });
+}
+
+/**
+ * @typedef ScpOptions
+ * @property {string} hostname
+ * @property {string} source
+ * @property {string} destination
+ * @property {string[]} [identityPaths]
+ * @property {string} [port]
+ * @property {string} [username]
+ * @property {number} [retries]
+ */
+
+/**
+ * @param {ScpOptions} options
+ * @returns {Promise<void>}
+ */
+async function spawnScp(options) {
+  const { hostname, port, username, identityPaths, source, destination, retries = 10 } = options;
+  await waitForPort({ hostname, port: port || 22 });
+
+  const command = ["scp", "-o", "StrictHostKeyChecking=no", "-o", "BatchMode=yes"];
+  if (port) {
+    command.push("-P", port);
+  }
+  if (identityPaths) {
+    command.push(...identityPaths.flatMap(path => ["-i", path]));
+  }
+  command.push(resolve(source));
+  if (username) {
+    command.push(`${username}@${hostname}:${destination}`);
+  } else {
+    command.push(`${hostname}:${destination}`);
+  }
+
+  let cause;
+  for (let i = 0; i < retries; i++) {
+    const result = await spawn(command, { stdio: "inherit" });
+    const { exitCode, stderr } = result;
+    if (exitCode === 0) {
+      return;
+    }
+
+    cause = stderr.trim() || undefined;
+    if (/(bad configuration option)|(no such file or directory)/i.test(stderr)) {
+      break;
+    }
+    await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
+  }
+
+  throw new Error(`SCP failed: ${source} -> ${username}@${hostname}:${destination}`, { cause });
+}
+
+/**
+ * @typedef Cloud
+ * @property {string} name
+ * @property {(options: MachineOptions) => Promise<Machine>} createMachine
+ */
+
+/**
+ * @param {string} name
+ * @returns {Cloud}
+ */
+function getCloud(name) {
+  switch (name) {
+    case "aws":
+      return aws;
+  }
+  throw new Error(`Unsupported cloud: ${name}`);
+}
+
+/**
+ * @typedef Machine
+ * @property {string} cloud
+ * @property {string} [name]
+ * @property {string} id
+ * @property {string} imageId
+ * @property {string} instanceType
+ * @property {string} region
+ * @property {string} [publicIp]
+ * @property {(command: string[]) => Promise<SpawnResult>} spawn
+ * @property {(command: string[]) => Promise<SpawnResult>} spawnSafe
+ * @property {(source: string, destination: string) => Promise<void>} upload
+ * @property {() => Promise<void>} attach
+ * @property {() => Promise<string>} snapshot
+ * @property {() => Promise<void>} close
+ */
+
+/**
+ * @typedef {"linux" | "darwin" | "windows"} Os
+ * @typedef {"aarch64" | "x64"} Arch
+ */
+
+/**
+ * @typedef MachineOptions
+ * @property {Cloud} cloud
+ * @property {Os} os
+ * @property {Arch} arch
+ * @property {string} distro
+ * @property {string} [distroVersion]
+ * @property {string} [imageId]
+ * @property {string} [imageName]
+ * @property {number} [cpuCount]
+ * @property {number} [memoryGb]
+ * @property {number} [diskSizeGb]
+ * @property {boolean} [persistent]
+ * @property {boolean} [detached]
+ * @property {Record<string, unknown>} [tags]
+ * @property {boolean} [bootstrap]
+ * @property {boolean} [ci]
+ * @property {SshKey[]} [sshKeys]
+ */
+
+async function main() {
+  const { positionals } = parseArgs({
+    allowPositionals: true,
+    strict: false,
+  });
+
+  const [command] = positionals;
+  if (!/^(ssh|create-image|publish-image)$/.test(command)) {
+    const scriptPath = relative(process.cwd(), fileURLToPath(import.meta.url));
+    throw new Error(`Usage: ./${scriptPath} [ssh|create-image|publish-image] [options]`);
+  }
+
+  const { values: args } = parseArgs({
+    allowPositionals: true,
+    options: {
+      "cloud": { type: "string", default: "aws" },
+      "os": { type: "string", default: "linux" },
+      "arch": { type: "string", default: "x64" },
+      "distro": { type: "string" },
+      "distro-version": { type: "string" },
+      "instance-type": { type: "string" },
+      "image-id": { type: "string" },
+      "image-name": { type: "string" },
+      "cpu-count": { type: "string" },
+      "memory-gb": { type: "string" },
+      "disk-size-gb": { type: "string" },
+      "persistent": { type: "boolean" },
+      "detached": { type: "boolean" },
+      "tag": { type: "string", multiple: true },
+      "ci": { type: "boolean" },
+      "no-bootstrap": { type: "boolean" },
+      "buildkite-token": { type: "string" },
+      "tailscale-authkey": { type: "string" },
+    },
+  });
+
+  /** @type {MachineOptions} */
+  const options = {
+    cloud: getCloud(args["cloud"]),
+    os: parseOs(args["os"]),
+    arch: parseArch(args["arch"]),
+    distro: args["distro"],
+    distroVersion: args["distro-version"],
+    instanceType: args["instance-type"],
+    imageId: args["image-id"],
+    imageName: args["image-name"],
+    tags: {
+      "robobun": "true",
+      "robobun2": "true",
+      "buildkite:token": args["buildkite-token"],
+      "tailscale:authkey": args["tailscale-authkey"],
+      ...Object.fromEntries(args["tag"]?.map(tag => tag.split("=")) ?? []),
+    },
+    cpuCount: parseInt(args["cpu-count"]) || undefined,
+    memoryGb: parseInt(args["memory-gb"]) || undefined,
+    diskSizeGb: parseInt(args["disk-size-gb"]) || undefined,
+    persistent: !!args["persistent"],
+    detached: !!args["detached"],
+    bootstrap: args["no-bootstrap"] !== true,
+    ci: !!args["ci"],
+    sshKeys: getSshKeys(),
+  };
+
+  const { cloud, detached, bootstrap, ci, os, arch, distro, distroVersion } = options;
+  const name = `${os}-${arch}-${distro}-${distroVersion}`;
+
+  let bootstrapPath, agentPath;
+  if (bootstrap) {
+    bootstrapPath = resolve(import.meta.dirname, os === "windows" ? "bootstrap.ps1" : "bootstrap.sh");
+    if (!existsSync(bootstrapPath)) {
+      throw new Error(`Script not found: ${bootstrapPath}`);
+    }
+    if (ci) {
+      const npx = which("bunx") || which("npx");
+      if (!npx) {
+        throw new Error("Executable not found: bunx or npx");
+      }
+      const entryPath = resolve(import.meta.dirname, "agent.mjs");
+      const tmpPath = mkdtempSync(join(tmpdir(), "agent-"));
+      agentPath = join(tmpPath, "agent.mjs");
+      await spawnSafe($`${npx} esbuild ${entryPath} --bundle --platform=node --format=esm --outfile=${agentPath}`);
+    }
+  }
+
+  /** @type {Machine} */
+  const machine = await startGroup("Creating machine...", async () => {
+    console.log("Creating machine:", JSON.parse(JSON.stringify(options)));
+    const result = await cloud.createMachine(options);
+    console.log("Created machine:", result);
+    return result;
+  });
+
+  if (!detached) {
+    let closing;
+    for (const event of ["beforeExit", "SIGINT", "SIGTERM"]) {
+      process.on(event, () => {
+        if (!closing) {
+          closing = true;
+          machine.close().finally(() => {
+            if (event !== "beforeExit") {
+              process.exit(1);
+            }
+          });
+        }
+      });
+    }
+  }
+
+  try {
+    await startGroup("Connecting...", async () => {
+      const command = os === "windows" ? ["cmd", "/c", "ver"] : ["uname", "-a"];
+      await machine.spawnSafe(command, { stdio: "inherit" });
+    });
+
+    if (bootstrapPath) {
+      if (os === "windows") {
+        const remotePath = "C:\\Windows\\Temp\\bootstrap.ps1";
+        const args = ci ? ["-CI"] : [];
+        await startGroup("Running bootstrap...", async () => {
+          await machine.upload(bootstrapPath, remotePath);
+          await machine.spawnSafe(["powershell", remotePath, ...args], { stdio: "inherit" });
+        });
+      } else {
+        const remotePath = "/tmp/bootstrap.sh";
+        const args = ci ? ["--ci"] : [];
+        await startGroup("Running bootstrap...", async () => {
+          await machine.upload(bootstrapPath, remotePath);
+          await machine.spawnSafe(["sh", remotePath, ...args], { stdio: "inherit" });
+        });
+      }
+    }
+
+    if (agentPath) {
+      if (os === "windows") {
+        // TODO
+        // const remotePath = "C:\\Windows\\Temp\\agent.mjs";
+        // await startGroup("Installing agent...", async () => {
+        //   await machine.upload(agentPath, remotePath);
+        //   await machine.spawnSafe(["node", remotePath, "install"], { stdio: "inherit" });
+        // });
+      } else {
+        const tmpPath = "/tmp/agent.mjs";
+        const remotePath = "/var/lib/buildkite-agent/agent.mjs";
+        await startGroup("Installing agent...", async () => {
+          await machine.upload(agentPath, tmpPath);
+          const command = [];
+          {
+            const { exitCode } = await machine.spawn(["sudo", "echo", "1"], { stdio: "ignore" });
+            if (exitCode === 0) {
+              command.unshift("sudo");
+            }
+          }
+          await machine.spawnSafe([...command, "cp", tmpPath, remotePath]);
+          {
+            const { stdout } = await machine.spawn(["node", "-v"]);
+            const version = parseInt(stdout.trim().replace(/^v/, ""));
+            if (isNaN(version) || version < 20) {
+              command.push("bun");
+            } else {
+              command.push("node");
+            }
+          }
+          await machine.spawnSafe([...command, remotePath, "install"], { stdio: "inherit" });
+        });
+      }
+    }
+
+    if (command === "create-image" || command === "publish-image") {
+      let suffix;
+      if (command === "publish-image") {
+        suffix = `v${getBootstrapVersion()}`;
+      } else if (isCI) {
+        suffix = `build-${getBuildNumber()}`;
+      } else {
+        suffix = `draft-${Date.now()}`;
+      }
+      const label = `${name}-${suffix}`;
+      await startGroup("Creating image...", async () => {
+        console.log("Creating image:", label);
+        const result = await machine.snapshot(label);
+        console.log("Created image:", result);
+      });
+    }
+
+    if (command === "ssh") {
+      await machine.attach();
+    }
+  } catch (error) {
+    if (isCI) {
+      throw error;
+    }
+    console.error(error);
+    try {
+      await machine.attach();
+    } catch (error) {
+      console.error(error);
+    }
+  } finally {
+    if (!detached) {
+      await machine.close();
+    }
+  }
+}
+
+await main();
diff --git a/scripts/runner.node.mjs b/scripts/runner.node.mjs
index 898b596a50f313..792c825ac13460 100755
--- a/scripts/runner.node.mjs
+++ b/scripts/runner.node.mjs
@@ -39,7 +39,7 @@ import {
 } from "./utils.mjs";
 import { userInfo } from "node:os";
 
-const cwd = dirname(import.meta.dirname);
+const cwd = import.meta.dirname ? dirname(import.meta.dirname) : process.cwd();
 const testsPath = join(cwd, "test");
 
 const spawnTimeout = 5_000;
@@ -232,7 +232,7 @@ async function runTests() {
         if (testRunner === "bun") {
           await runTest(title, () => spawnBunTest(execPath, testPath, { cwd: vendorPath }));
         } else {
-          const testRunnerPath = join(import.meta.dirname, "..", "test", "runners", `${testRunner}.ts`);
+          const testRunnerPath = join(cwd, "test", "runners", `${testRunner}.ts`);
           if (!existsSync(testRunnerPath)) {
             throw new Error(`Unsupported test runner: ${testRunner}`);
           }
@@ -632,7 +632,7 @@ function parseTestStdout(stdout, testPath) {
           const removeStart = lines.length - skipCount;
           const removeCount = skipCount - 2;
           const omitLine = `${getAnsi("gray")}... omitted ${removeCount} tests ...${getAnsi("reset")}`;
-          lines = lines.toSpliced(removeStart, removeCount, omitLine);
+          lines.splice(removeStart, removeCount, omitLine);
         }
         skipCount = 0;
       }
@@ -1133,6 +1133,13 @@ function addPath(...paths) {
   return paths.join(":");
 }
 
+/**
+ * @returns {string | undefined}
+ */
+function getTestLabel() {
+  return getBuildLabel()?.replace(" - test-bun", "");
+}
+
 /**
  * @param  {TestResult | TestResult[]} result
  * @param  {boolean} concise
@@ -1140,7 +1147,7 @@ function addPath(...paths) {
  */
 function formatTestToMarkdown(result, concise) {
   const results = Array.isArray(result) ? result : [result];
-  const buildLabel = getBuildLabel();
+  const buildLabel = getTestLabel();
   const buildUrl = getBuildUrl();
   const platform = buildUrl ? `<a href="${buildUrl}">${buildLabel}</a>` : buildLabel;
 
@@ -1273,7 +1280,7 @@ function reportAnnotationToBuildKite({ label, content, style = "error", priority
     const cause = error ?? signal ?? `code ${status}`;
     throw new Error(`Failed to create annotation: ${label}`, { cause });
   }
-  const buildLabel = getBuildLabel();
+  const buildLabel = getTestLabel();
   const buildUrl = getBuildUrl();
   const platform = buildUrl ? `<a href="${buildUrl}">${buildLabel}</a>` : buildLabel;
   let errorMessage = `<details><summary><a><code>${label}</code></a> - annotation error on ${platform}</summary>`;
diff --git a/scripts/utils.mjs b/scripts/utils.mjs
old mode 100644
new mode 100755
index 185bebf7d7aa48..17a27da7a74fa9
--- a/scripts/utils.mjs
+++ b/scripts/utils.mjs
@@ -3,9 +3,18 @@
 
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { hostname, tmpdir as nodeTmpdir, userInfo } from "node:os";
+import {
+  appendFileSync,
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { connect } from "node:net";
+import { hostname, tmpdir as nodeTmpdir, userInfo, release } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { normalize as normalizeWindows } from "node:path/win32";
 
@@ -53,8 +62,9 @@ export function getSecret(name, options = { required: true, redact: true }) {
       command.push("--skip-redaction");
     }
 
-    const { error, stdout: secret } = spawnSync(command);
-    if (error || !secret.trim()) {
+    const { error, stdout } = spawnSync(command);
+    const secret = stdout.trim();
+    if (error || !secret) {
       const orgId = getEnv("BUILDKITE_ORGANIZATION_SLUG", false);
       const clusterId = getEnv("BUILDKITE_CLUSTER_ID", false);
 
@@ -106,8 +116,8 @@ export function setEnv(name, value) {
  * @property {string} [cwd]
  * @property {number} [timeout]
  * @property {Record<string, string | undefined>} [env]
- * @property {string} [stdout]
- * @property {string} [stderr]
+ * @property {string} [stdin]
+ * @property {boolean} [privileged]
  */
 
 /**
@@ -119,20 +129,93 @@ export function setEnv(name, value) {
  * @property {Error} [error]
  */
 
+/**
+ * @param {TemplateStringsArray} strings
+ * @param {...any} values
+ * @returns {string[]}
+ */
+export function $(strings, ...values) {
+  const result = [];
+  for (let i = 0; i < strings.length; i++) {
+    result.push(...strings[i].trim().split(/\s+/).filter(Boolean));
+    if (i < values.length) {
+      const value = values[i];
+      if (Array.isArray(value)) {
+        result.push(...value);
+      } else if (typeof value === "string") {
+        if (result.at(-1)?.endsWith("=")) {
+          result[result.length - 1] += value;
+        } else {
+          result.push(value);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+/** @type {string[] | undefined} */
+let priviledgedCommand;
+
+/**
+ * @param {string[]} command
+ * @param {SpawnOptions} options
+ */
+function parseCommand(command, options) {
+  if (options?.privileged) {
+    return [...getPrivilegedCommand(), ...command];
+  }
+  return command;
+}
+
+/**
+ * @returns {string[]}
+ */
+function getPrivilegedCommand() {
+  if (typeof priviledgedCommand !== "undefined") {
+    return priviledgedCommand;
+  }
+
+  if (isWindows) {
+    return (priviledgedCommand = []);
+  }
+
+  const sudo = ["sudo", "-n"];
+  const { error: sudoError } = spawnSync([...sudo, "true"]);
+  if (!sudoError) {
+    return (priviledgedCommand = sudo);
+  }
+
+  const su = ["su", "-s", "sh", "root", "-c"];
+  const { error: suError } = spawnSync([...su, "true"]);
+  if (!suError) {
+    return (priviledgedCommand = su);
+  }
+
+  const doas = ["doas", "-u", "root"];
+  const { error: doasError } = spawnSync([...doas, "true"]);
+  if (!doasError) {
+    return (priviledgedCommand = doas);
+  }
+
+  return (priviledgedCommand = []);
+}
+
 /**
  * @param {string[]} command
  * @param {SpawnOptions} options
  * @returns {Promise<SpawnResult>}
  */
 export async function spawn(command, options = {}) {
-  debugLog("$", ...command);
+  const [cmd, ...args] = parseCommand(command, options);
+  debugLog("$", cmd, ...args);
 
-  const [cmd, ...args] = command;
+  const stdin = options["stdin"];
   const spawnOptions = {
     cwd: options["cwd"] ?? process.cwd(),
     timeout: options["timeout"] ?? undefined,
     env: options["env"] ?? undefined,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: [stdin ? "pipe" : "ignore", "pipe", "pipe"],
     ...options,
   };
 
@@ -145,6 +228,16 @@ export async function spawn(command, options = {}) {
   const result = new Promise((resolve, reject) => {
     const subprocess = nodeSpawn(cmd, args, spawnOptions);
 
+    if (typeof stdin !== "undefined") {
+      subprocess.stdin?.on("error", error => {
+        if (error.code !== "EPIPE") {
+          reject(error);
+        }
+      });
+      subprocess.stdin?.write(stdin);
+      subprocess.stdin?.end();
+    }
+
     subprocess.stdout?.on("data", chunk => {
       stdout += chunk;
     });
@@ -215,9 +308,9 @@ export async function spawnSafe(command, options) {
  * @returns {SpawnResult}
  */
 export function spawnSync(command, options = {}) {
-  debugLog("$", ...command);
+  const [cmd, ...args] = parseCommand(command, options);
+  debugLog("$", cmd, ...args);
 
-  const [cmd, ...args] = command;
   const spawnOptions = {
     cwd: options["cwd"] ?? process.cwd(),
     timeout: options["timeout"] ?? undefined,
@@ -245,8 +338,8 @@ export function spawnSync(command, options = {}) {
   } else {
     exitCode = status ?? 1;
     signalCode = signal || undefined;
-    stdout = stdoutBuffer.toString();
-    stderr = stderrBuffer.toString();
+    stdout = stdoutBuffer?.toString();
+    stderr = stderrBuffer?.toString();
   }
 
   if (exitCode !== 0 && isWindows) {
@@ -258,7 +351,7 @@ export function spawnSync(command, options = {}) {
 
   if (error || signalCode || exitCode !== 0) {
     const description = command.map(arg => (arg.includes(" ") ? `"${arg.replace(/"/g, '\\"')}"` : arg)).join(" ");
-    const cause = error || stderr.trim() || stdout.trim() || undefined;
+    const cause = error || stderr?.trim() || stdout?.trim() || undefined;
 
     if (signalCode) {
       error = new Error(`Command killed with ${signalCode}: ${description}`, { cause });
@@ -376,6 +469,20 @@ export function getRepository(cwd) {
   }
 }
 
+/**
+ * @param {string} [cwd]
+ * @returns {string | undefined}
+ */
+export function getRepositoryOwner(cwd) {
+  const repository = getRepository(cwd);
+  if (repository) {
+    const [owner] = repository.split("/");
+    if (owner) {
+      return owner;
+    }
+  }
+}
+
 /**
  * @param {string} [cwd]
  * @returns {string | undefined}
@@ -490,7 +597,7 @@ export function isMainBranch(cwd) {
  */
 export function isPullRequest() {
   if (isBuildkite) {
-    return getEnv("BUILDKITE_PULL_REQUEST", false) === "true";
+    return !isNaN(parseInt(getEnv("BUILDKITE_PULL_REQUEST", false)));
   }
 
   if (isGithubAction) {
@@ -656,7 +763,7 @@ export async function curl(url, options = {}) {
     try {
       if (filename && ok) {
         const buffer = await response.arrayBuffer();
-        await writeFile(filename, new Uint8Array(buffer));
+        writeFile(filename, new Uint8Array(buffer));
       } else if (arrayBuffer && ok) {
         body = await response.arrayBuffer();
       } else if (json && ok) {
@@ -721,7 +828,7 @@ export function readFile(filename, options = {}) {
   }
 
   const relativePath = relative(process.cwd(), absolutePath);
-  debugLog("cat", relativePath);
+  debugLog("$", "cat", relativePath);
 
   let content;
   try {
@@ -738,6 +845,53 @@ export function readFile(filename, options = {}) {
   return content;
 }
 
+/**
+ * @param {string} filename
+ * @param {string | Buffer} content
+ * @param {object} [options]
+ * @param {number} [options.mode]
+ */
+export function writeFile(filename, content, options = {}) {
+  const parent = dirname(filename);
+  if (!existsSync(parent)) {
+    mkdirSync(parent, { recursive: true });
+  }
+
+  writeFileSync(filename, content);
+
+  if (options["mode"]) {
+    chmodSync(filename, options["mode"]);
+  }
+}
+
+/**
+ * @param {string | string[]} command
+ * @param {object} [options]
+ * @param {boolean} [options.required]
+ * @returns {string | undefined}
+ */
+export function which(command, options = {}) {
+  const commands = Array.isArray(command) ? command : [command];
+  const executables = isWindows ? commands.flatMap(name => [name, `${name}.exe`, `${name}.cmd`]) : commands;
+
+  const path = getEnv("PATH", false) || "";
+  const binPaths = path.split(isWindows ? ";" : ":");
+
+  for (const binPath of binPaths) {
+    for (const executable of executables) {
+      const executablePath = join(binPath, executable);
+      if (existsSync(executablePath)) {
+        return executablePath;
+      }
+    }
+  }
+
+  if (options["required"]) {
+    const description = commands.join(" or ");
+    throw new Error(`Command not found: ${description}`);
+  }
+}
+
 /**
  * @param {string} [cwd]
  * @param {string} [base]
@@ -746,10 +900,10 @@ export function readFile(filename, options = {}) {
  */
 export async function getChangedFiles(cwd, base, head) {
   const repository = getRepository(cwd);
-  base ||= getCommit(cwd);
-  head ||= `${base}^1`;
+  head ||= getCommit(cwd);
+  base ||= `${head}^1`;
 
-  const url = `https://api.github.com/repos/${repository}/compare/${head}...${base}`;
+  const url = `https://api.github.com/repos/${repository}/compare/${base}...${head}`;
   const { error, body } = await curl(url, { json: true });
 
   if (error) {
@@ -826,7 +980,7 @@ export function getBuildUrl() {
  */
 export function getBuildLabel() {
   if (isBuildkite) {
-    const label = getEnv("BUILDKITE_GROUP_LABEL", false) || getEnv("BUILDKITE_LABEL", false);
+    const label = getEnv("BUILDKITE_LABEL", false) || getEnv("BUILDKITE_GROUP_LABEL", false);
     if (label) {
       return label;
     }
@@ -840,6 +994,22 @@ export function getBuildLabel() {
   }
 }
 
+/**
+ * @returns {number}
+ */
+export function getBootstrapVersion() {
+  if (isWindows) {
+    return 0; // TODO
+  }
+  const scriptPath = join(import.meta.dirname, "bootstrap.sh");
+  const scriptContent = readFile(scriptPath, { cache: true });
+  const match = /# Version: (\d+)/.exec(scriptContent);
+  if (match) {
+    return parseInt(match[1]);
+  }
+  return 0;
+}
+
 /**
  * @typedef {object} BuildArtifact
  * @property {string} [job]
@@ -1013,6 +1183,17 @@ export async function getLastSuccessfulBuild() {
   }
 }
 
+/**
+ * @param {string} filename
+ * @param {string} [cwd]
+ */
+export async function uploadArtifact(filename, cwd) {
+  if (isBuildkite) {
+    const relativePath = relative(cwd ?? process.cwd(), filename);
+    await spawnSafe(["buildkite-agent", "artifact", "upload", relativePath], { cwd, stdio: "inherit" });
+  }
+}
+
 /**
  * @param {string} string
  * @returns {string}
@@ -1021,6 +1202,17 @@ export function stripAnsi(string) {
   return string.replace(/\u001b\[\d+m/g, "");
 }
 
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function escapeYaml(string) {
+  if (/[:"{}[\],&*#?|\-<>=!%@`]/.test(string)) {
+    return `"${string.replace(/"/g, '\\"')}"`;
+  }
+  return string;
+}
+
 /**
  * @param {string} string
  * @returns {string}
@@ -1059,6 +1251,14 @@ export function escapeCodeBlock(string) {
   return string.replace(/`/g, "\\`");
 }
 
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+export function escapePowershell(string) {
+  return string.replace(/'/g, "''").replace(/`/g, "``");
+}
+
 /**
  * @returns {string}
  */
@@ -1090,14 +1290,6 @@ export function tmpdir() {
   return nodeTmpdir();
 }
 
-/**
- * @param {string} string
- * @returns {string}
- */
-function escapePowershell(string) {
-  return string.replace(/'/g, "''").replace(/`/g, "``");
-}
-
 /**
  * @param {string} filename
  * @param {string} [output]
@@ -1159,24 +1351,79 @@ export function getArch() {
   return parseArch(process.arch);
 }
 
+/**
+ * @returns {string}
+ */
+export function getKernel() {
+  const kernel = release();
+  const match = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(kernel);
+
+  if (match) {
+    const [, major, minor, patch] = match;
+    if (patch) {
+      return `${major}.${minor}.${patch}`;
+    }
+    return `${major}.${minor}`;
+  }
+
+  return kernel;
+}
+
 /**
  * @returns {"musl" | "gnu" | undefined}
  */
 export function getAbi() {
-  if (isLinux) {
-    const arch = getArch() === "x64" ? "x86_64" : "aarch64";
-    const muslLibPath = `/lib/ld-musl-${arch}.so.1`;
-    if (existsSync(muslLibPath)) {
+  if (!isLinux) {
+    return;
+  }
+
+  if (existsSync("/etc/alpine-release")) {
+    return "musl";
+  }
+
+  const arch = getArch() === "x64" ? "x86_64" : "aarch64";
+  const muslLibPath = `/lib/ld-musl-${arch}.so.1`;
+  if (existsSync(muslLibPath)) {
+    return "musl";
+  }
+
+  const gnuLibPath = `/lib/ld-linux-${arch}.so.2`;
+  if (existsSync(gnuLibPath)) {
+    return "gnu";
+  }
+
+  const { error, stdout } = spawnSync(["ldd", "--version"]);
+  if (!error) {
+    if (/musl/i.test(stdout)) {
       return "musl";
     }
-
-    const gnuLibPath = `/lib/ld-linux-${arch}.so.2`;
-    if (existsSync(gnuLibPath)) {
+    if (/gnu|glibc/i.test(stdout)) {
       return "gnu";
     }
   }
 }
 
+/**
+ * @returns {string | undefined}
+ */
+export function getAbiVersion() {
+  if (!isLinux) {
+    return;
+  }
+
+  const { error, stdout } = spawnSync(["ldd", "--version"]);
+  if (!error) {
+    const match = /(\d+)\.(\d+)(?:\.(\d+))?/.exec(stdout);
+    if (match) {
+      const [, major, minor, patch] = match;
+      if (patch) {
+        return `${major}.${minor}.${patch}`;
+      }
+      return `${major}.${minor}`;
+    }
+  }
+}
+
 /**
  * @typedef {object} Target
  * @property {"darwin" | "linux" | "windows"} os
@@ -1346,17 +1593,24 @@ export async function downloadTarget(target, release) {
 }
 
 /**
- * @returns {string | undefined}
+ * @returns {string}
  */
-export function getTailscaleIp() {
-  let tailscale = "tailscale";
+export function getTailscale() {
   if (isMacOS) {
     const tailscaleApp = "/Applications/Tailscale.app/Contents/MacOS/tailscale";
     if (existsSync(tailscaleApp)) {
-      tailscale = tailscaleApp;
+      return tailscaleApp;
     }
   }
 
+  return "tailscale";
+}
+
+/**
+ * @returns {string | undefined}
+ */
+export function getTailscaleIp() {
+  const tailscale = getTailscale();
   const { error, stdout } = spawnSync([tailscale, "ip", "--1"]);
   if (!error) {
     return stdout.trim();
@@ -1405,7 +1659,31 @@ export function getUsername() {
 }
 
 /**
- * @returns {string}
+ * @typedef {object} User
+ * @property {string} username
+ * @property {number} uid
+ * @property {number} gid
+ */
+
+/**
+ * @param {string} username
+ * @returns {Promise<User>}
+ */
+export async function getUser(username) {
+  if (isWindows) {
+    throw new Error("TODO: Windows");
+  }
+
+  const [uid, gid] = await Promise.all([
+    spawnSafe(["id", "-u", username]).then(({ stdout }) => parseInt(stdout.trim())),
+    spawnSafe(["id", "-g", username]).then(({ stdout }) => parseInt(stdout.trim())),
+  ]);
+
+  return { username, uid, gid };
+}
+
+/**
+ * @returns {string | undefined}
  */
 export function getDistro() {
   if (isMacOS) {
@@ -1413,10 +1691,15 @@ export function getDistro() {
   }
 
   if (isLinux) {
+    const alpinePath = "/etc/alpine-release";
+    if (existsSync(alpinePath)) {
+      return "alpine";
+    }
+
     const releasePath = "/etc/os-release";
     if (existsSync(releasePath)) {
       const releaseFile = readFile(releasePath, { cache: true });
-      const match = releaseFile.match(/ID=\"(.*)\"/);
+      const match = releaseFile.match(/^ID=\"?(.*)\"?/m);
       if (match) {
         return match[1];
       }
@@ -1424,10 +1707,8 @@ export function getDistro() {
 
     const { error, stdout } = spawnSync(["lsb_release", "-is"]);
     if (!error) {
-      return stdout.trim();
+      return stdout.trim().toLowerCase();
     }
-
-    return "Linux";
   }
 
   if (isWindows) {
@@ -1435,17 +1716,13 @@ export function getDistro() {
     if (!error) {
       return stdout.trim();
     }
-
-    return "Windows";
   }
-
-  return `${process.platform} ${process.arch}`;
 }
 
 /**
  * @returns {string | undefined}
  */
-export function getDistroRelease() {
+export function getDistroVersion() {
   if (isMacOS) {
     const { error, stdout } = spawnSync(["sw_vers", "-productVersion"]);
     if (!error) {
@@ -1454,10 +1731,20 @@ export function getDistroRelease() {
   }
 
   if (isLinux) {
+    const alpinePath = "/etc/alpine-release";
+    if (existsSync(alpinePath)) {
+      const release = readFile(alpinePath, { cache: true }).trim();
+      if (release.includes("_")) {
+        const [version] = release.split("_");
+        return `${version}-edge`;
+      }
+      return release;
+    }
+
     const releasePath = "/etc/os-release";
     if (existsSync(releasePath)) {
       const releaseFile = readFile(releasePath, { cache: true });
-      const match = releaseFile.match(/VERSION_ID=\"(.*)\"/);
+      const match = releaseFile.match(/^VERSION_ID=\"?(.*)\"?/m);
       if (match) {
         return match[1];
       }
@@ -1477,6 +1764,231 @@ export function getDistroRelease() {
   }
 }
 
+/**
+ * @typedef {"aws" | "google"} Cloud
+ */
+
+/** @type {Cloud | undefined} */
+let detectedCloud;
+
+/**
+ * @returns {Promise<boolean | undefined>}
+ */
+export async function isAws() {
+  if (typeof detectedCloud === "string") {
+    return detectedCloud === "aws";
+  }
+
+  async function checkAws() {
+    if (isLinux) {
+      const kernel = release();
+      if (kernel.endsWith("-aws")) {
+        return true;
+      }
+
+      const { error: systemdError, stdout } = await spawn(["systemd-detect-virt"]);
+      if (!systemdError) {
+        if (stdout.includes("amazon")) {
+          return true;
+        }
+      }
+
+      const dmiPath = "/sys/devices/virtual/dmi/id/board_asset_tag";
+      if (existsSync(dmiPath)) {
+        const dmiFile = readFileSync(dmiPath, { encoding: "utf-8" });
+        if (dmiFile.startsWith("i-")) {
+          return true;
+        }
+      }
+    }
+
+    if (isWindows) {
+      const executionEnv = getEnv("AWS_EXECUTION_ENV", false);
+      if (executionEnv === "EC2") {
+        return true;
+      }
+
+      const { error: powershellError, stdout } = await spawn([
+        "powershell",
+        "-Command",
+        "Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object Manufacturer",
+      ]);
+      if (!powershellError) {
+        return stdout.includes("Amazon");
+      }
+    }
+
+    const instanceId = await getCloudMetadata("instance-id", "google");
+    if (instanceId) {
+      return true;
+    }
+  }
+
+  if (await checkAws()) {
+    detectedCloud = "aws";
+    return true;
+  }
+}
+
+/**
+ * @returns {Promise<boolean | undefined>}
+ */
+export async function isGoogleCloud() {
+  if (typeof detectedCloud === "string") {
+    return detectedCloud === "google";
+  }
+
+  async function detectGoogleCloud() {
+    if (isLinux) {
+      const vendorPaths = [
+        "/sys/class/dmi/id/sys_vendor",
+        "/sys/class/dmi/id/bios_vendor",
+        "/sys/class/dmi/id/product_name",
+      ];
+
+      for (const vendorPath of vendorPaths) {
+        if (existsSync(vendorPath)) {
+          const vendorFile = readFileSync(vendorPath, { encoding: "utf-8" });
+          if (vendorFile.includes("Google")) {
+            return true;
+          }
+        }
+      }
+    }
+
+    const instanceId = await getCloudMetadata("id", "google");
+    if (instanceId) {
+      return true;
+    }
+  }
+
+  if (await detectGoogleCloud()) {
+    detectedCloud = "google";
+    return true;
+  }
+}
+
+/**
+ * @returns {Promise<Cloud | undefined>}
+ */
+export async function getCloud() {
+  if (typeof detectedCloud === "string") {
+    return detectedCloud;
+  }
+
+  if (await isAws()) {
+    return "aws";
+  }
+
+  if (await isGoogleCloud()) {
+    return "google";
+  }
+}
+
+/**
+ * @param {string | Record<Cloud, string>} name
+ * @param {Cloud} [cloud]
+ * @returns {Promise<string | undefined>}
+ */
+export async function getCloudMetadata(name, cloud) {
+  cloud ??= await getCloud();
+  if (!cloud) {
+    return;
+  }
+
+  if (typeof name === "object") {
+    name = name[cloud];
+  }
+
+  let url;
+  let headers;
+  if (cloud === "aws") {
+    url = new URL(name, "http://169.254.169.254/latest/meta-data/");
+  } else if (cloud === "google") {
+    url = new URL(name, "http://metadata.google.internal/computeMetadata/v1/instance/");
+    headers = { "Metadata-Flavor": "Google" };
+  } else {
+    throw new Error(`Unsupported cloud: ${inspect(cloud)}`);
+  }
+
+  const { error, body } = await curl(url, { headers, retries: 0 });
+  if (error) {
+    return;
+  }
+
+  return body.trim();
+}
+
+/**
+ * @param {string} tag
+ * @param {Cloud} [cloud]
+ * @returns {Promise<string | undefined>}
+ */
+export function getCloudMetadataTag(tag, cloud) {
+  const metadata = {
+    "aws": `tags/instance/${tag}`,
+  };
+
+  return getCloudMetadata(metadata, cloud);
+}
+
+/**
+ * @param {string} name
+ * @returns {Promise<string | undefined>}
+ */
+export async function getBuildMetadata(name) {
+  if (isBuildkite) {
+    const { error, stdout } = await spawn(["buildkite-agent", "meta-data", "get", name]);
+    if (!error) {
+      const value = stdout.trim();
+      if (value) {
+        return value;
+      }
+    }
+  }
+}
+
+/**
+ * @typedef ConnectOptions
+ * @property {string} hostname
+ * @property {number} port
+ * @property {number} [retries]
+ */
+
+/**
+ * @param {ConnectOptions} options
+ * @returns {Promise<Error | undefined>}
+ */
+export async function waitForPort(options) {
+  const { hostname, port, retries = 10 } = options;
+
+  let cause;
+  for (let i = 0; i < retries; i++) {
+    if (cause) {
+      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
+    }
+
+    const connected = new Promise((resolve, reject) => {
+      const socket = connect({ host: hostname, port });
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve();
+      });
+      socket.on("error", error => {
+        socket.destroy();
+        reject(error);
+      });
+    });
+
+    try {
+      return await connected;
+    } catch (error) {
+      cause = error;
+    }
+  }
+
+  return cause;
+}
 /**
  * @returns {Promise<number | undefined>}
  */
@@ -1522,6 +2034,52 @@ export function getGithubUrl() {
   return new URL(getEnv("GITHUB_SERVER_URL", false) || "https://github.com");
 }
 
+/**
+ * @param {object} obj
+ * @param {number} indent
+ * @returns {string}
+ */
+export function toYaml(obj, indent = 0) {
+  const spaces = " ".repeat(indent);
+  let result = "";
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined) {
+      continue;
+    }
+    if (value === null) {
+      result += `${spaces}${key}: null\n`;
+      continue;
+    }
+    if (Array.isArray(value)) {
+      result += `${spaces}${key}:\n`;
+      value.forEach(item => {
+        if (typeof item === "object" && item !== null) {
+          result += `${spaces}- \n${toYaml(item, indent + 2)
+            .split("\n")
+            .map(line => `${spaces}  ${line}`)
+            .join("\n")}\n`;
+        } else {
+          result += `${spaces}- ${item}\n`;
+        }
+      });
+      continue;
+    }
+    if (typeof value === "object") {
+      result += `${spaces}${key}:\n${toYaml(value, indent + 2)}`;
+      continue;
+    }
+    if (
+      typeof value === "string" &&
+      (value.includes(":") || value.includes("#") || value.includes("'") || value.includes('"') || value.includes("\n"))
+    ) {
+      result += `${spaces}${key}: "${value.replace(/"/g, '\\"')}"\n`;
+      continue;
+    }
+    result += `${spaces}${key}: ${value}\n`;
+  }
+  return result;
+}
+
 /**
  * @param {string} title
  * @param {function} [fn]
@@ -1561,11 +2119,13 @@ export function printEnvironment() {
   startGroup("Machine", () => {
     console.log("Operating System:", getOs());
     console.log("Architecture:", getArch());
+    console.log("Kernel:", getKernel());
     if (isLinux) {
       console.log("ABI:", getAbi());
+      console.log("ABI Version:", getAbiVersion());
     }
     console.log("Distro:", getDistro());
-    console.log("Release:", getDistroRelease());
+    console.log("Distro Version:", getDistroVersion());
     console.log("Hostname:", getHostname());
     if (isCI) {
       console.log("Tailscale IP:", getTailscaleIp());
diff --git a/src/ArenaAllocator.zig b/src/ArenaAllocator.zig
deleted file mode 100644
index 4c62038cabc63a..00000000000000
--- a/src/ArenaAllocator.zig
+++ /dev/null
@@ -1,248 +0,0 @@
-const std = @import("std");
-const bun = @import("root").bun;
-const assert = bun.assert;
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-
-/// This allocator takes an existing allocator, wraps it, and provides an interface
-/// where you can allocate without freeing, and then free it all together.
-pub const ArenaAllocator = struct {
-    child_allocator: Allocator,
-    state: State,
-
-    /// Inner state of ArenaAllocator. Can be stored rather than the entire ArenaAllocator
-    /// as a memory-saving optimization.
-    pub const State = struct {
-        buffer_list: std.SinglyLinkedList(usize) = .{},
-        end_index: usize = 0,
-
-        pub fn promote(self: State, child_allocator: Allocator) ArenaAllocator {
-            return .{
-                .child_allocator = child_allocator,
-                .state = self,
-            };
-        }
-    };
-
-    pub fn allocator(self: *ArenaAllocator) Allocator {
-        return .{
-            .ptr = self,
-            .vtable = &.{
-                .alloc = alloc,
-                .resize = resize,
-                .free = free,
-            },
-        };
-    }
-
-    const BufNode = std.SinglyLinkedList(usize).Node;
-
-    pub fn init(child_allocator: Allocator) ArenaAllocator {
-        return (State{}).promote(child_allocator);
-    }
-
-    pub fn deinit(self: ArenaAllocator) void {
-        // NOTE: When changing this, make sure `reset()` is adjusted accordingly!
-
-        var it = self.state.buffer_list.first;
-        while (it) |node| {
-            // this has to occur before the free because the free frees node
-            const next_it = node.next;
-            const align_bits = std.math.log2_int(usize, @alignOf(BufNode));
-            const alloc_buf = @as([*]u8, @ptrCast(node))[0..node.data];
-            self.child_allocator.rawFree(alloc_buf, align_bits, @returnAddress());
-            it = next_it;
-        }
-    }
-
-    pub const ResetMode = union(enum) {
-        /// Releases all allocated memory in the arena.
-        free_all,
-        /// This will pre-heat the arena for future allocations by allocating a
-        /// large enough buffer for all previously done allocations.
-        /// Preheating will speed up the allocation process by invoking the backing allocator
-        /// less often than before. If `reset()` is used in a loop, this means that after the
-        /// biggest operation, no memory allocations are performed anymore.
-        retain_capacity,
-        /// This is the same as `retain_capacity`, but the memory will be shrunk to
-        /// this value if it exceeds the limit.
-        retain_with_limit: usize,
-    };
-    /// Queries the current memory use of this arena.
-    /// This will **not** include the storage required for internal keeping.
-    pub fn queryCapacity(self: ArenaAllocator) usize {
-        var size: usize = 0;
-        var it = self.state.buffer_list.first;
-        while (it) |node| : (it = node.next) {
-            // Compute the actually allocated size excluding the
-            // linked list node.
-            size += node.data - @sizeOf(BufNode);
-        }
-        return size;
-    }
-    /// Resets the arena allocator and frees all allocated memory.
-    ///
-    /// `mode` defines how the currently allocated memory is handled.
-    /// See the variant documentation for `ResetMode` for the effects of each mode.
-    ///
-    /// The function will return whether the reset operation was successful or not.
-    /// If the reallocation  failed `false` is returned. The arena will still be fully
-    /// functional in that case, all memory is released. Future allocations just might
-    /// be slower.
-    ///
-    /// NOTE: If `mode` is `free_mode`, the function will always return `true`.
-    pub fn reset(self: *ArenaAllocator, mode: ResetMode) bool {
-        // Some words on the implementation:
-        // The reset function can be implemented with two basic approaches:
-        // - Counting how much bytes were allocated since the last reset, and storing that
-        //   information in State. This will make reset fast and alloc only a teeny tiny bit
-        //   slower.
-        // - Counting how much bytes were allocated by iterating the chunk linked list. This
-        //   will make reset slower, but alloc() keeps the same speed when reset() as if reset()
-        //   would not exist.
-        //
-        // The second variant was chosen for implementation, as with more and more calls to reset(),
-        // the function will get faster and faster. At one point, the complexity of the function
-        // will drop to amortized O(1), as we're only ever having a single chunk that will not be
-        // reallocated, and we're not even touching the backing allocator anymore.
-        //
-        // Thus, only the first hand full of calls to reset() will actually need to iterate the linked
-        // list, all future calls are just taking the first node, and only resetting the `end_index`
-        // value.
-        const requested_capacity = switch (mode) {
-            .retain_capacity => self.queryCapacity(),
-            .retain_with_limit => |limit| @min(limit, self.queryCapacity()),
-            .free_all => 0,
-        };
-        if (requested_capacity == 0) {
-            // just reset when we don't have anything to reallocate
-            self.deinit();
-            self.state = State{};
-            return true;
-        }
-        const total_size = requested_capacity + @sizeOf(BufNode);
-        const align_bits = std.math.log2_int(usize, @alignOf(BufNode));
-        // Free all nodes except for the last one
-        var it = self.state.buffer_list.first;
-        const maybe_first_node = while (it) |node| {
-            // this has to occur before the free because the free frees node
-            const next_it = node.next;
-            if (next_it == null)
-                break node;
-            const alloc_buf = @as([*]u8, @ptrCast(node))[0..node.data];
-            self.child_allocator.rawFree(alloc_buf, align_bits, @returnAddress());
-            it = next_it;
-        } else null;
-        assert(maybe_first_node == null or maybe_first_node.?.next == null);
-        // reset the state before we try resizing the buffers, so we definitely have reset the arena to 0.
-        self.state.end_index = 0;
-        if (maybe_first_node) |first_node| {
-            self.state.buffer_list.first = first_node;
-            // perfect, no need to invoke the child_allocator
-            if (first_node.data == total_size)
-                return true;
-            const first_alloc_buf = @as([*]u8, @ptrCast(first_node))[0..first_node.data];
-            if (self.child_allocator.rawResize(first_alloc_buf, align_bits, total_size, @returnAddress())) {
-                // successful resize
-                first_node.data = total_size;
-            } else {
-                // manual realloc
-                const new_ptr = self.child_allocator.rawAlloc(total_size, align_bits, @returnAddress()) orelse {
-                    // we failed to preheat the arena properly, signal this to the user.
-                    return false;
-                };
-                self.child_allocator.rawFree(first_alloc_buf, align_bits, @returnAddress());
-                const node: *BufNode = @ptrCast(@alignCast(new_ptr));
-                node.* = .{ .data = total_size };
-                self.state.buffer_list.first = node;
-            }
-        }
-        return true;
-    }
-
-    fn createNode(self: *ArenaAllocator, prev_len: usize, minimum_size: usize) ?*BufNode {
-        const actual_min_size = minimum_size + (@sizeOf(BufNode) + 16);
-        const big_enough_len = prev_len + actual_min_size;
-        const len = big_enough_len + big_enough_len / 2;
-        const log2_align = comptime std.math.log2_int(usize, @alignOf(BufNode));
-        const ptr = self.child_allocator.rawAlloc(len, log2_align, @returnAddress()) orelse
-            return null;
-        const buf_node: *BufNode = @ptrCast(@alignCast(ptr));
-        buf_node.* = .{ .data = len };
-        self.state.buffer_list.prepend(buf_node);
-        self.state.end_index = 0;
-        return buf_node;
-    }
-
-    fn alloc(ctx: *anyopaque, n: usize, log2_ptr_align: u8, ra: usize) ?[*]u8 {
-        const self: *ArenaAllocator = @ptrCast(@alignCast(ctx));
-        _ = ra;
-
-        const ptr_align = @as(usize, 1) << @as(Allocator.Log2Align, @intCast(log2_ptr_align));
-        var cur_node = if (self.state.buffer_list.first) |first_node|
-            first_node
-        else
-            (self.createNode(0, n + ptr_align) orelse return null);
-        while (true) {
-            const cur_alloc_buf = @as([*]u8, @ptrCast(cur_node))[0..cur_node.data];
-            const cur_buf = cur_alloc_buf[@sizeOf(BufNode)..];
-            const addr = @intFromPtr(cur_buf.ptr) + self.state.end_index;
-            const adjusted_addr = mem.alignForward(usize, addr, ptr_align);
-            const adjusted_index = self.state.end_index + (adjusted_addr - addr);
-            const new_end_index = adjusted_index + n;
-
-            if (new_end_index <= cur_buf.len) {
-                const result = cur_buf[adjusted_index..new_end_index];
-                self.state.end_index = new_end_index;
-                return result.ptr;
-            }
-
-            const bigger_buf_size = @sizeOf(BufNode) + new_end_index;
-            const log2_align = comptime std.math.log2_int(usize, @alignOf(BufNode));
-            if (self.child_allocator.rawResize(cur_alloc_buf, log2_align, bigger_buf_size, @returnAddress())) {
-                cur_node.data = bigger_buf_size;
-            } else {
-                // Allocate a new node if that's not possible
-                cur_node = self.createNode(cur_buf.len, n + ptr_align) orelse return null;
-            }
-        }
-    }
-
-    fn resize(ctx: *anyopaque, buf: []u8, log2_buf_align: u8, new_len: usize, ret_addr: usize) bool {
-        const self: *ArenaAllocator = @ptrCast(@alignCast(ctx));
-        _ = log2_buf_align;
-        _ = ret_addr;
-
-        const cur_node = self.state.buffer_list.first orelse return false;
-        const cur_buf = @as([*]u8, @ptrCast(cur_node))[@sizeOf(BufNode)..cur_node.data];
-        if (@intFromPtr(cur_buf.ptr) + self.state.end_index != @intFromPtr(buf.ptr) + buf.len) {
-            // It's not the most recent allocation, so it cannot be expanded,
-            // but it's fine if they want to make it smaller.
-            return new_len <= buf.len;
-        }
-
-        if (buf.len >= new_len) {
-            self.state.end_index -= buf.len - new_len;
-            return true;
-        } else if (cur_buf.len - self.state.end_index >= new_len - buf.len) {
-            self.state.end_index += new_len - buf.len;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    fn free(ctx: *anyopaque, buf: []u8, log2_buf_align: u8, ret_addr: usize) void {
-        _ = log2_buf_align;
-        _ = ret_addr;
-
-        const self: *ArenaAllocator = @ptrCast(@alignCast(ctx));
-
-        const cur_node = self.state.buffer_list.first orelse return;
-        const cur_buf = @as([*]u8, @ptrCast(cur_node))[@sizeOf(BufNode)..cur_node.data];
-
-        if (@intFromPtr(cur_buf.ptr) + self.state.end_index == @intFromPtr(buf.ptr) + buf.len) {
-            self.state.end_index -= buf.len;
-        }
-    }
-};
diff --git a/src/Global.zig b/src/Global.zig
index 94b0bc70c3bdb4..b219cf74671067 100644
--- a/src/Global.zig
+++ b/src/Global.zig
@@ -118,6 +118,10 @@ pub fn exit(code: u32) noreturn {
 
     switch (Environment.os) {
         .mac => std.c.exit(@bitCast(code)),
+        .windows => {
+            Bun__onExit();
+            std.os.windows.kernel32.ExitProcess(code);
+        },
         else => bun.C.quick_exit(@bitCast(code)),
     }
 }
diff --git a/src/StandaloneModuleGraph.zig b/src/StandaloneModuleGraph.zig
index a58989280f8b97..e3daa4da1713db 100644
--- a/src/StandaloneModuleGraph.zig
+++ b/src/StandaloneModuleGraph.zig
@@ -1072,7 +1072,7 @@ pub const StandaloneModuleGraph = struct {
             if (item.data != .e_string)
                 return error.InvalidSourceMap;
 
-            const decoded = try item.data.e_string.stringDecodedUTF8(arena);
+            const decoded = try item.data.e_string.stringCloned(arena);
 
             const offset = string_payload.items.len;
             try string_payload.appendSlice(decoded);
@@ -1089,7 +1089,7 @@ pub const StandaloneModuleGraph = struct {
             if (item.data != .e_string)
                 return error.InvalidSourceMap;
 
-            const utf8 = try item.data.e_string.stringDecodedUTF8(arena);
+            const utf8 = try item.data.e_string.stringCloned(arena);
             defer arena.free(utf8);
 
             const offset = string_payload.items.len;
diff --git a/src/allocators.zig b/src/allocators.zig
index 727146960f8f55..5b3fd6cc824314 100644
--- a/src/allocators.zig
+++ b/src/allocators.zig
@@ -177,6 +177,11 @@ pub fn OverflowList(comptime ValueType: type, comptime count: comptime_int) type
     };
 }
 
+/// "Formerly-BSSList"
+/// It's not actually BSS anymore.
+///
+/// We do keep a pointer to it globally, but because the data is not zero-initialized, it ends up taking space in the object file.
+/// We don't want to spend 1-2 MB on these structs.
 pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
     const count = _count * 2;
     const max_index = count - 1;
@@ -205,7 +210,7 @@ pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
         backing_buf: [count]ValueType = undefined,
         used: u32 = 0,
 
-        pub var instance: Self = undefined;
+        pub var instance: *Self = undefined;
         pub var loaded = false;
 
         pub inline fn blockIndex(index: u31) usize {
@@ -214,7 +219,8 @@ pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
 
         pub fn init(allocator: std.mem.Allocator) *Self {
             if (!loaded) {
-                instance = Self{
+                instance = bun.default_allocator.create(Self) catch bun.outOfMemory();
+                instance.* = Self{
                     .allocator = allocator,
                     .tail = OverflowBlock{},
                 };
@@ -222,7 +228,7 @@ pub fn BSSList(comptime ValueType: type, comptime _count: anytype) type {
                 loaded = true;
             }
 
-            return &instance;
+            return instance;
         }
 
         pub fn isOverflowing() bool {
@@ -289,7 +295,7 @@ pub fn BSSStringList(comptime _count: usize, comptime _item_length: usize) type
         slice_buf: [count][]const u8 = undefined,
         slice_buf_used: u16 = 0,
         mutex: Mutex = .{},
-        pub var instance: Self = undefined;
+        pub var instance: *Self = undefined;
         var loaded: bool = false;
         // only need the mutex on append
 
@@ -299,14 +305,15 @@ pub fn BSSStringList(comptime _count: usize, comptime _item_length: usize) type
 
         pub fn init(allocator: std.mem.Allocator) *Self {
             if (!loaded) {
-                instance = Self{
+                instance = bun.default_allocator.create(Self) catch bun.outOfMemory();
+                instance.* = Self{
                     .allocator = allocator,
                     .backing_buf_used = 0,
                 };
                 loaded = true;
             }
 
-            return &instance;
+            return instance;
         }
 
         pub inline fn isOverflowing() bool {
@@ -469,20 +476,21 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
         backing_buf: [count]ValueType = undefined,
         backing_buf_used: u16 = 0,
 
-        pub var instance: Self = undefined;
+        pub var instance: *Self = undefined;
 
         var loaded: bool = false;
 
         pub fn init(allocator: std.mem.Allocator) *Self {
             if (!loaded) {
-                instance = Self{
+                instance = bun.default_allocator.create(Self) catch bun.outOfMemory();
+                instance.* = Self{
                     .index = IndexMap{},
                     .allocator = allocator,
                 };
                 loaded = true;
             }
 
-            return &instance;
+            return instance;
         }
 
         pub fn isOverflowing() bool {
@@ -621,18 +629,19 @@ pub fn BSSMap(comptime ValueType: type, comptime count: anytype, comptime store_
         key_list_overflow: OverflowList([]u8, count / 4) = OverflowList([]u8, count / 4){},
 
         const Self = @This();
-        pub var instance: Self = undefined;
+        pub var instance: *Self = undefined;
         pub var instance_loaded = false;
 
         pub fn init(allocator: std.mem.Allocator) *Self {
             if (!instance_loaded) {
-                instance = Self{
+                instance = bun.default_allocator.create(Self) catch bun.outOfMemory();
+                instance.* = Self{
                     .map = BSSMapType.init(allocator),
                 };
                 instance_loaded = true;
             }
 
-            return &instance;
+            return instance;
         }
 
         pub fn isOverflowing() bool {
diff --git a/src/api/schema.zig b/src/api/schema.zig
index fa851862807022..002f43223f1e2e 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -2816,7 +2816,7 @@ pub const Api = struct {
 
             fn expectString(this: *Parser, expr: js_ast.Expr) !void {
                 switch (expr.data) {
-                    .e_string, .e_utf8_string => {},
+                    .e_string => {},
                     else => {
                         this.log.addErrorFmt(this.source, expr.loc, this.allocator, "expected string but received {}", .{
                             @as(js_ast.Expr.Tag, expr.data),
diff --git a/src/bake/BakeGlobalObject.cpp b/src/bake/BakeGlobalObject.cpp
index 14b8809fc8b34f..44ee0e1854ae02 100644
--- a/src/bake/BakeGlobalObject.cpp
+++ b/src/bake/BakeGlobalObject.cpp
@@ -2,38 +2,50 @@
 #include "JSNextTickQueue.h"
 #include "JavaScriptCore/GlobalObjectMethodTable.h"
 #include "JavaScriptCore/JSInternalPromise.h"
-#include "ProcessIdentifier.h"
 #include "headers-handwritten.h"
+#include "JavaScriptCore/JSModuleLoader.h"
+#include "JavaScriptCore/Completion.h"
 
-namespace Bake {
+extern "C" BunString BakeProdResolve(JSC::JSGlobalObject*, BunString a, BunString b);
 
-extern "C" void BakeInitProcessIdentifier()
-{
-    // assert is on main thread
-    WebCore::Process::identifier();
-}
+namespace Bake {
 
 JSC::JSInternalPromise*
-bakeModuleLoaderImportModule(JSC::JSGlobalObject* jsGlobalObject,
-    JSC::JSModuleLoader*, JSC::JSString* moduleNameValue,
+bakeModuleLoaderImportModule(JSC::JSGlobalObject* global,
+    JSC::JSModuleLoader* moduleLoader, JSC::JSString* moduleNameValue,
     JSC::JSValue parameters,
     const JSC::SourceOrigin& sourceOrigin)
 {
-    // TODO: forward this to the runtime?
-    JSC::VM& vm = jsGlobalObject->vm();
-    WTF::String keyString = moduleNameValue->getString(jsGlobalObject);
-    auto err = JSC::createTypeError(
-        jsGlobalObject,
-        WTF::makeString(
-            "Dynamic import to '"_s, keyString,
-            "' should have been replaced with a hook into the module runtime"_s));
-    auto* promise = JSC::JSInternalPromise::create(
-        vm, jsGlobalObject->internalPromiseStructure());
-    promise->reject(jsGlobalObject, err);
-    return promise;
-}
+    WTF::String keyString = moduleNameValue->getString(global);
+    if (keyString.startsWith("bake:/"_s)) {
+        JSC::VM& vm = global->vm();
+        return JSC::importModule(global, JSC::Identifier::fromString(vm, keyString),
+            JSC::jsUndefined(), parameters, JSC::jsUndefined());
+    }
 
-extern "C" BunString BakeProdResolve(JSC::JSGlobalObject*, BunString a, BunString b);
+    if (!sourceOrigin.isNull() && sourceOrigin.string().startsWith("bake:/"_s)) {
+        JSC::VM& vm = global->vm();
+        auto scope = DECLARE_THROW_SCOPE(vm);
+
+        WTF::String refererString = sourceOrigin.string();
+        WTF::String keyString = moduleNameValue->getString(global);
+
+        if (!keyString) {
+            auto promise = JSC::JSInternalPromise::create(vm, global->internalPromiseStructure());
+            promise->reject(global, JSC::createError(global, "import() requires a string"_s));
+            return promise;
+        }
+
+        BunString result = BakeProdResolve(global, Bun::toString(refererString), Bun::toString(keyString));
+        RETURN_IF_EXCEPTION(scope, nullptr);
+
+        return JSC::importModule(global, JSC::Identifier::fromString(vm, result.toWTFString()),
+            JSC::jsUndefined(), parameters, JSC::jsUndefined());
+    }
+
+    // Use Zig::GlobalObject's function
+    return jsCast<Zig::GlobalObject*>(global)->moduleLoaderImportModule(global, moduleLoader, moduleNameValue, parameters, sourceOrigin);
+}
 
 JSC::Identifier bakeModuleLoaderResolve(JSC::JSGlobalObject* jsGlobal,
     JSC::JSModuleLoader* loader, JSC::JSValue key,
@@ -43,19 +55,21 @@ JSC::Identifier bakeModuleLoaderResolve(JSC::JSGlobalObject* jsGlobal,
     JSC::VM& vm = global->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    if (global->isProduction()) {
-        WTF::String keyString = key.toWTFString(global);
-        RETURN_IF_EXCEPTION(scope, vm.propertyNames->emptyIdentifier);
+    ASSERT(referrer.isString());
+    WTF::String refererString = jsCast<JSC::JSString*>(referrer)->getString(global);
 
-        ASSERT(referrer.isString());
-        auto refererString = jsCast<JSC::JSString*>(referrer)->value(global);
+    WTF::String keyString = key.toWTFString(global);
+    RETURN_IF_EXCEPTION(scope, vm.propertyNames->emptyIdentifier);
 
+    if (refererString.startsWith("bake:/"_s) || (refererString == "."_s && keyString.startsWith("bake:/"_s))) {
         BunString result = BakeProdResolve(global, Bun::toString(referrer.getString(global)), Bun::toString(keyString));
+        RETURN_IF_EXCEPTION(scope, vm.propertyNames->emptyIdentifier);
+
         return JSC::Identifier::fromString(vm, result.toWTFString(BunString::ZeroCopy));
-    } else {
-        JSC::throwTypeError(global, scope, "External imports are not allowed in Bun Bake's dev server. This is a bug in Bun's bundler."_s);
-        return vm.propertyNames->emptyIdentifier;
     }
+
+    // Use Zig::GlobalObject's function
+    return Zig::GlobalObject::moduleLoaderResolve(jsGlobal, loader, key, referrer, origin);
 }
 
 #define INHERIT_HOOK_METHOD(name) \
@@ -100,12 +114,12 @@ void GlobalObject::finishCreation(JSC::VM& vm)
     ASSERT(inherits(info()));
 }
 
+struct BunVirtualMachine;
 extern "C" BunVirtualMachine* Bun__getVM();
 
 // A lot of this function is taken from 'Zig__GlobalObject__create'
 // TODO: remove this entire method
-extern "C" GlobalObject* BakeCreateDevGlobal(DevServer* owner,
-    void* console)
+extern "C" GlobalObject* BakeCreateProdGlobal(void* console)
 {
     JSC::VM& vm = JSC::VM::create(JSC::HeapType::Large).leakRef();
     vm.heap.acquireAccess();
@@ -119,7 +133,6 @@ extern "C" GlobalObject* BakeCreateDevGlobal(DevServer* owner,
     if (!global)
         BUN_PANIC("Failed to create BakeGlobalObject");
 
-    global->m_devServer = owner;
     global->m_bunVM = bunVM;
 
     JSC::gcProtect(global);
@@ -142,25 +155,4 @@ extern "C" GlobalObject* BakeCreateDevGlobal(DevServer* owner,
     return global;
 }
 
-extern "C" GlobalObject* BakeCreateProdGlobal(JSC::VM* vm, void* console)
-{
-    JSC::JSLockHolder locker(vm);
-    BunVirtualMachine* bunVM = Bun__getVM();
-
-    JSC::Structure* structure = GlobalObject::createStructure(*vm);
-    GlobalObject* global = GlobalObject::create(*vm, structure, &GlobalObject::s_globalObjectMethodTable);
-    if (!global)
-        BUN_PANIC("Failed to create BakeGlobalObject");
-
-    global->m_devServer = nullptr;
-    global->m_bunVM = bunVM;
-
-    JSC::gcProtect(global);
-
-    global->setConsole(console);
-    global->setStackTraceLimit(10); // Node.js defaults to 10
-
-    return global;
-}
-
 }; // namespace Bake
diff --git a/src/bake/BakeGlobalObject.h b/src/bake/BakeGlobalObject.h
index 406a509ec1588c..af2b3490f96b4d 100644
--- a/src/bake/BakeGlobalObject.h
+++ b/src/bake/BakeGlobalObject.h
@@ -4,17 +4,10 @@
 
 namespace Bake {
 
-struct DevServer; // DevServer.zig
-struct Route; // DevServer.zig
-struct BunVirtualMachine;
-
 class GlobalObject : public Zig::GlobalObject {
 public:
     using Base = Zig::GlobalObject;
 
-    /// Null if in production
-    DevServer* m_devServer;
-
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
@@ -31,16 +24,10 @@ class GlobalObject : public Zig::GlobalObject {
     static const JSC::GlobalObjectMethodTable s_globalObjectMethodTable;
     static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable);
 
-    ALWAYS_INLINE bool isProduction() const { return !m_devServer; }
-
     void finishCreation(JSC::VM& vm);
 
     GlobalObject(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable) 
         : Zig::GlobalObject(vm, structure, methodTable) { }
 };
 
-// Zig API
-extern "C" void KitInitProcessIdentifier();
-extern "C" GlobalObject* KitCreateDevGlobal(DevServer* owner, void* console);
-
 }; // namespace Kit
diff --git a/src/bake/BakeProduction.cpp b/src/bake/BakeProduction.cpp
index 726a8ea258538d..887dbb565e8b68 100644
--- a/src/bake/BakeProduction.cpp
+++ b/src/bake/BakeProduction.cpp
@@ -6,25 +6,33 @@
 
 namespace Bake {
 
-extern "C" JSC::JSPromise* BakeRenderRoutesForProd(
+extern "C" JSC::JSPromise* BakeRenderRoutesForProdStatic(
     JSC::JSGlobalObject* global,
-    BunString outbase,
-    JSC::JSValue renderStaticCallback,
+    BunString outBase,
+    JSC::JSValue allServerFiles,
+    JSC::JSValue renderStatic,
     JSC::JSValue clientEntryUrl,
+    JSC::JSValue pattern,
     JSC::JSValue files,
-    JSC::JSValue patterns,
+    JSC::JSValue typeAndFlags,
+    JSC::JSValue sourceRouteFiles,
+    JSC::JSValue paramInformation,
     JSC::JSValue styles)
 {
     JSC::VM& vm = global->vm();
-    JSC::JSFunction* cb = JSC::JSFunction::create(vm, global, WebCore::bakeRenderRoutesForProdCodeGenerator(vm), global);
+    JSC::JSFunction* cb = JSC::JSFunction::create(vm, global, WebCore::bakeRenderRoutesForProdStaticCodeGenerator(vm), global);
     JSC::CallData callData = JSC::getCallData(cb);
 
     JSC::MarkedArgumentBuffer args;
-    args.append(JSC::jsString(vm, outbase.toWTFString()));
-    args.append(renderStaticCallback);
+    args.append(JSC::jsString(vm, outBase.toWTFString()));
+    args.append(allServerFiles);
+    args.append(renderStatic);
     args.append(clientEntryUrl);
+    args.append(pattern);
     args.append(files);
-    args.append(patterns);
+    args.append(typeAndFlags);
+    args.append(sourceRouteFiles);
+    args.append(paramInformation);
     args.append(styles);
 
     NakedPtr<JSC::Exception> returnedException = nullptr;
diff --git a/src/bake/BakeSourceProvider.cpp b/src/bake/BakeSourceProvider.cpp
index b821d136703192..cf7ef839ab8284 100644
--- a/src/bake/BakeSourceProvider.cpp
+++ b/src/bake/BakeSourceProvider.cpp
@@ -8,33 +8,40 @@
 #include "JavaScriptCore/JSLock.h"
 #include "JavaScriptCore/JSMap.h"
 #include "JavaScriptCore/JSModuleLoader.h"
+#include "JavaScriptCore/JSModuleRecord.h"
 #include "JavaScriptCore/JSString.h"
 #include "JavaScriptCore/JSModuleNamespaceObject.h"
+#include "ImportMetaObject.h"
 
 namespace Bake {
 
-extern "C" LoadServerCodeResult BakeLoadInitialServerCode(GlobalObject* global, BunString source) {
+extern "C" JSC::EncodedJSValue BakeLoadInitialServerCode(GlobalObject* global, BunString source, bool separateSSRGraph) {
   JSC::VM& vm = global->vm();
   auto scope = DECLARE_THROW_SCOPE(vm);
 
-  String string = "bake://server.js"_s;
-  JSC::JSString* key = JSC::jsString(vm, string);
+  String string = "bake://server-runtime.js"_s;
   JSC::SourceOrigin origin = JSC::SourceOrigin(WTF::URL(string));
   JSC::SourceCode sourceCode = JSC::SourceCode(DevSourceProvider::create(
     source.toWTFString(),
     origin,
     WTFMove(string),
     WTF::TextPosition(),
-    JSC::SourceProviderSourceType::Module
+    JSC::SourceProviderSourceType::Program
   ));
 
-  global->moduleLoader()->provideFetch(global, key, sourceCode);
-  RETURN_IF_EXCEPTION(scope, {});
- 
-  JSC::JSInternalPromise* internalPromise = global->moduleLoader()->loadAndEvaluateModule(global, key, JSC::jsUndefined(), JSC::jsUndefined());
-  RETURN_IF_EXCEPTION(scope, {});
+  JSC::JSValue fnValue = vm.interpreter.executeProgram(sourceCode, global, global);
+  RETURN_IF_EXCEPTION(scope, JSC::JSValue::encode({}));
+
+  RELEASE_ASSERT(fnValue);
+
+  JSC::JSFunction* fn = jsCast<JSC::JSFunction*>(fnValue);
+  JSC::CallData callData = JSC::getCallData(fn);
+
+  JSC::MarkedArgumentBuffer args;
+  args.append(JSC::jsBoolean(separateSSRGraph)); // separateSSRGraph
+  args.append(Zig::ImportMetaObject::create(global, "bake://server-runtime.js"_s)); // importMeta
 
-  return { internalPromise, key };
+  return JSC::JSValue::encode(JSC::call(global, fn, callData, JSC::jsUndefined(), args));
 }
 
 extern "C" JSC::JSInternalPromise* BakeLoadModuleByKey(GlobalObject* global, JSC::JSString* key) {
diff --git a/src/bake/BakeSourceProvider.h b/src/bake/BakeSourceProvider.h
index 191dd927f72c9d..2d821fc40116d0 100644
--- a/src/bake/BakeSourceProvider.h
+++ b/src/bake/BakeSourceProvider.h
@@ -6,11 +6,6 @@
 
 namespace Bake {
 
-struct LoadServerCodeResult {
-  JSC::JSInternalPromise* promise;
-  JSC::JSString* key;
-};
-
 class DevSourceProvider final : public JSC::StringSourceProvider {
 public:
     static Ref<DevSourceProvider> create(
diff --git a/src/bake/DevServer.zig b/src/bake/DevServer.zig
index c07599f638dc0d..fe5e658d45d414 100644
--- a/src/bake/DevServer.zig
+++ b/src/bake/DevServer.zig
@@ -1,7 +1,11 @@
-//! Instance of the development server. Controls an event loop, web server,
-//! bundling state, filesystem watcher, and JavaScript VM instance.
+//! Instance of the development server. Attaches to an instance of `Bun.serve`,
+//! controlling bundler, routing, and hot module reloading.
 //!
-//! All work is cached in-memory.
+//! Reprocessing files that did not change is banned; by having perfect
+//! incremental tracking over the project, editing a file's contents (asides
+//! adjusting imports) must always rebundle only that one file.
+//!
+//! All work is held in-memory, using manually managed data-oriented design.
 //!
 //! TODO: Currently does not have a `deinit()`, as it was assumed to be alive for
 //! the remainder of this process' lifespan. Later, it will be required to fully
@@ -11,14 +15,12 @@ pub const debug = bun.Output.Scoped(.Bake, false);
 pub const igLog = bun.Output.scoped(.IncrementalGraph, false);
 
 pub const Options = struct {
-    allocator: ?Allocator = null, // defaults to a named heap
-    cwd: []u8,
-    routes: []Route,
+    root: []const u8,
     framework: bake.Framework,
-    listen_config: uws.AppListenConfig = .{ .port = 3000 },
     dump_sources: ?[]const u8 = if (Environment.isDebug) ".bake-debug" else null,
+    dump_state_on_crash: bool = bun.FeatureFlags.bake_debugging_features,
     verbose_watcher: bool = false,
-    // TODO: make it required to inherit a js VM
+    vm: *VirtualMachine,
 };
 
 // The fields `client_graph`, `server_graph`, and `directory_watchers` all
@@ -29,28 +31,48 @@ pub const Options = struct {
 /// Used for all server-wide allocations. In debug, this shows up in
 /// a separate named heap. Thread-safe.
 allocator: Allocator,
-/// Project root directory. For the HMR runtime, its
-/// module IDs are strings relative to this.
-cwd: []const u8,
+/// Absolute path to project root directory. For the HMR
+/// runtime, its module IDs are strings relative to this.
+root: []const u8,
 /// Hex string generated by hashing the framework config and bun revision.
 /// Emebedding in client bundles and sent when the HMR Socket is opened;
 /// When the value mismatches the page is forcibly reloaded.
 configuration_hash_key: [16]u8,
-
-// UWS App
-app: *App,
-routes: []Route,
-address: struct {
-    port: u16,
-    hostname: [*:0]const u8,
-},
-listener: ?*App.ListenSocket,
-
-// Server Runtime
-server_global: *DevGlobalObject,
+/// The virtual machine (global object) to execute code in.
 vm: *VirtualMachine,
+/// May be `null` if not attached to an HTTP server yet.
+server: ?bun.JSC.API.AnyServer,
+/// Contains the tree of routes. This structure contains FileIndex
+router: FrameworkRouter,
+/// Every navigatable route has bundling state here.
+route_bundles: ArrayListUnmanaged(RouteBundle),
+/// All access into IncrementalGraph is guarded by a DebugThreadLock. This is
+/// only a debug assertion as contention to this is always a bug; If a bundle is
+/// active and a file is changed, that change is placed into the next bundle.
+graph_safety_lock: bun.DebugThreadLock,
+client_graph: IncrementalGraph(.client),
+server_graph: IncrementalGraph(.server),
+/// State populated during bundling and hot updates. Often cleared
+incremental_result: IncrementalResult,
+/// CSS files are accessible via `/_bun/css/<hex key>.css`
+/// Value is bundled code owned by `dev.allocator`
+css_files: AutoArrayHashMapUnmanaged(u64, []const u8),
+/// JS files are accessible via `/_bun/client/route.<hex key>.js`
+/// These are randomly generated to avoid possible browser caching of old assets.
+route_js_payloads: AutoArrayHashMapUnmanaged(u64, Route.Index),
+// /// Assets are accessible via `/_bun/asset/<key>`
+// assets: bun.StringArrayHashMapUnmanaged(u64, Asset),
+/// All bundling failures are stored until a file is saved and rebuilt.
+/// They are stored in the wire format the HMR runtime expects so that
+/// serialization only happens once.
+bundling_failures: std.ArrayHashMapUnmanaged(
+    SerializedFailure,
+    void,
+    SerializedFailure.ArrayHashContextViaOwner,
+    false,
+) = .{},
 
-// These values are handles to the functions in server_exports.
+// These values are handles to the functions in `hmr-runtime-server.ts`.
 // For type definitions, see `./bake.private.d.ts`
 server_fetch_function_callback: JSC.Strong,
 server_register_update_callback: JSC.Strong,
@@ -67,79 +89,70 @@ watch_events: [2]HotReloadTask.Aligned,
 watch_state: std.atomic.Value(u32),
 watch_current: u1 = 0,
 
-// Bundling
+/// Number of bundles that have been executed. This is currently not read, but
+/// will be used later to determine when to invoke graph garbage collection.
 generation: usize = 0,
+/// Displayed in the HMR success indicator
 bundles_since_last_error: usize = 0,
-/// All access into IncrementalGraph is guarded by this. This is only
-/// a debug assertion since there is no actual contention.
-graph_safety_lock: bun.DebugThreadLock,
-client_graph: IncrementalGraph(.client),
-server_graph: IncrementalGraph(.server),
-/// CSS files are accessible via `/_bun/css/<hex key>.css`
-/// Value is bundled code.
-css_files: AutoArrayHashMapUnmanaged(u64, []const u8),
-// /// Assets are accessible via `/_bun/asset/<key>`
-// assets: bun.StringArrayHashMapUnmanaged(u64, Asset),
-/// All bundling failures are stored until a file is saved and rebuilt.
-/// They are stored in the wire format the HMR runtime expects so that
-/// serialization only happens once.
-bundling_failures: std.ArrayHashMapUnmanaged(
-    SerializedFailure,
-    void,
-    SerializedFailure.ArrayHashContextViaOwner,
-    false,
-) = .{},
-/// Quickly retrieve a route's index from the entry point file.
-route_lookup: AutoArrayHashMapUnmanaged(IncrementalGraph(.server).FileIndex, Route.Index),
-/// State populated during bundling. Often cleared
-incremental_result: IncrementalResult,
+
+/// Quickly retrieve a route's index from the entry point file. These are
+/// populated as the routes are discovered. The route may not be bundled or
+/// navigatable, in the case a layout's index is looked up.
+route_lookup: AutoArrayHashMapUnmanaged(IncrementalGraph(.server).FileIndex, RouteIndexAndRecurseFlag),
+
 framework: bake.Framework,
 // Each logical graph gets its own bundler configuration
 server_bundler: Bundler,
 client_bundler: Bundler,
 ssr_bundler: Bundler,
+
+// TODO: This being shared state is likely causing a crash
 /// Stored and reused for bundling tasks
 log: Log,
 
 // Debugging
 dump_dir: ?std.fs.Dir,
+/// Reference count to number of active sockets with the visualizer enabled.
 emit_visualizer_events: u32,
+has_pre_crash_handler: bool,
 
 pub const internal_prefix = "/_bun";
 pub const client_prefix = internal_prefix ++ "/client";
 pub const asset_prefix = internal_prefix ++ "/asset";
 pub const css_prefix = internal_prefix ++ "/css";
 
-pub const Route = struct {
-    pub const Index = bun.GenericIndex(u30, Route);
+pub const RouteBundle = struct {
+    pub const Index = bun.GenericIndex(u30, RouteBundle);
+
+    route: Route.Index,
 
-    // Config
-    pattern: [:0]const u8,
-    entry_point: []const u8,
+    server_state: State,
 
-    server_state: State = .unqueued,
-    /// Cached to avoid looking up by filename in `server_graph`
-    server_file: IncrementalGraph(.server).FileIndex.Optional = .none,
+    /// Used to communicate over WebSocket the pattern. The HMR client contains code
+    /// to match this against the URL bar to determine if a reloading route applies
+    /// or not.
+    full_pattern: []const u8,
     /// Generated lazily when the client JS is requested (HTTP GET /_bun/client/*.js),
     /// which is only needed when a hard-reload is performed.
     ///
     /// Freed when a client module updates.
-    client_bundle: ?[]const u8 = null,
+    client_bundle: ?[]const u8,
     /// Contain the list of serialized failures. Hashmap allows for
     /// efficient lookup and removal of failing files.
     /// When state == .evaluation_failure, this is popualted with that error.
-    evaluate_failure: ?SerializedFailure = null,
+    evaluate_failure: ?SerializedFailure,
 
-    /// Cached to avoid re-creating the string every request
-    module_name_string: JSC.Strong = .{},
-    /// Cached to avoid re-creating the string every request
-    client_bundle_url_value: JSC.Strong = .{},
-    /// Cached to avoid re-creating the array every request
-    css_file_array: JSC.Strong = .{},
+    // TODO: micro-opt: use a singular strong
 
-    /// Assigned in DevServer.init
-    dev: *DevServer = undefined,
-    client_bundled_url: []u8 = undefined,
+    /// Cached to avoid re-creating the array every request.
+    /// Invalidated when a layout is added or removed from this route.
+    cached_module_list: JSC.Strong,
+    /// Cached to avoid re-creating the string every request.
+    /// Invalidated when any client file associated with the route is updated.
+    cached_client_bundle_url: JSC.Strong,
+    /// Cached to avoid re-creating the array every request.
+    /// Invalidated when the list of CSS files changes.
+    cached_css_file_array: JSC.Strong,
 
     /// A union is not used so that `bundler_failure_logs` can re-use memory, as
     /// this state frequently changes between `loaded` and the failure variants.
@@ -147,8 +160,11 @@ pub const Route = struct {
         /// In development mode, routes are lazily built. This state implies a
         /// build of this route has never been run. It is possible to bundle the
         /// route entry point and still have an unqueued route if another route
-        /// imports this one.
+        /// imports this one. This state is implied if `FrameworkRouter.Route`
+        /// has no bundle index assigned.
         unqueued,
+        /// A bundle associated with this route is happening
+        bundling,
         /// This route was flagged for bundling failures. There are edge cases
         /// where a route can be disconnected from its failures, so the route
         /// imports has to be traced to discover if possible failures still
@@ -162,51 +178,48 @@ pub const Route = struct {
     };
 };
 
-const Asset = union(enum) {
-    /// File contents are allocated with `dev.allocator`
-    /// The slice is mirrored in `dev.client_graph.bundled_files`, so freeing this slice is not required.
-    css: []const u8,
-    /// A file path relative to cwd, owned by `dev.allocator`
-    file_path: []const u8,
+pub const DeferredRequest = struct {
+    next: ?*DeferredRequest,
+    bundle: RouteBundle.Index,
+    data: Data,
+
+    const Data = union(enum) {
+        server_handler: bun.JSC.API.SavedRequest,
+        /// onJsRequestWithBundle
+        js_payload: *Response,
+
+        const Tag = @typeInfo(Data).Union.tag_type.?;
+    };
 };
 
 /// DevServer is stored on the heap, storing its allocator.
+// TODO: change the error set to JSOrMemoryError!*DevServer
 pub fn init(options: Options) !*DevServer {
-    const allocator = options.allocator orelse bun.default_allocator;
+    const allocator = bun.default_allocator;
     bun.analytics.Features.kit_dev +|= 1;
-    if (JSC.VirtualMachine.VMHolder.vm != null)
-        @panic("Cannot initialize bake.DevServer on a thread with an active JSC.VirtualMachine");
-
-    const dump_dir = if (options.dump_sources) |dir|
-        std.fs.cwd().makeOpenPath(dir, .{}) catch |err| dir: {
-            bun.handleErrorReturnTrace(err, @errorReturnTrace());
-            Output.warn("Could not open directory for dumping sources: {}", .{err});
-            break :dir null;
-        }
-    else
-        null;
 
-    const app = App.create(.{}) orelse {
-        Output.prettyErrorln("Failed to create app", .{});
-        return error.AppInitialization;
-    };
+    var dump_dir = if (bun.FeatureFlags.bake_debugging_features)
+        if (options.dump_sources) |dir|
+            std.fs.cwd().makeOpenPath(dir, .{}) catch |err| dir: {
+                bun.handleErrorReturnTrace(err, @errorReturnTrace());
+                Output.warn("Could not open directory for dumping sources: {}", .{err});
+                break :dir null;
+            }
+        else
+            null;
+    errdefer if (bun.FeatureFlags.bake_debugging_features) if (dump_dir) |*dir| dir.close();
 
     const separate_ssr_graph = if (options.framework.server_components) |sc| sc.separate_ssr_graph else false;
 
     const dev = bun.create(allocator, DevServer, .{
         .allocator = allocator,
 
-        .cwd = options.cwd,
-        .app = app,
-        .routes = options.routes,
-        .address = .{
-            .port = @intCast(options.listen_config.port),
-            .hostname = options.listen_config.host orelse "localhost",
-        },
+        .root = options.root,
+        .vm = options.vm,
+        .server = null,
         .directory_watchers = DirectoryWatchStore.empty,
         .server_fetch_function_callback = .{},
         .server_register_update_callback = .{},
-        .listener = null,
         .generation = 0,
         .graph_safety_lock = .{},
         .log = Log.init(allocator),
@@ -215,7 +228,9 @@ pub fn init(options: Options) !*DevServer {
         .watch_state = .{ .raw = 0 },
         .watch_current = 0,
         .emit_visualizer_events = 0,
+        .has_pre_crash_handler = options.dump_state_on_crash,
         .css_files = .{},
+        .route_js_payloads = .{},
         // .assets = .{},
 
         .client_graph = IncrementalGraph(.client).empty,
@@ -227,13 +242,13 @@ pub fn init(options: Options) !*DevServer {
         .client_bundler = undefined,
         .ssr_bundler = undefined,
 
-        .server_global = undefined,
-        .vm = undefined,
-
         .bun_watcher = undefined,
         .watch_events = undefined,
 
         .configuration_hash_key = undefined,
+
+        .router = undefined,
+        .route_bundles = .{},
     });
     errdefer allocator.destroy(dev);
 
@@ -241,7 +256,10 @@ pub fn init(options: Options) !*DevServer {
     assert(dev.client_graph.owner() == dev);
     assert(dev.directory_watchers.owner() == dev);
 
-    const fs = try bun.fs.FileSystem.init(options.cwd);
+    dev.graph_safety_lock.lock();
+    defer dev.graph_safety_lock.unlock();
+
+    const fs = try bun.fs.FileSystem.init(options.root);
 
     dev.bun_watcher = try Watcher.init(DevServer, dev, fs, bun.default_allocator);
     errdefer dev.bun_watcher.deinit(false);
@@ -264,25 +282,16 @@ pub fn init(options: Options) !*DevServer {
         dev.ssr_bundler.options.dev_server = dev;
     }
 
-    dev.framework = dev.framework.resolve(
-        &dev.server_bundler.resolver,
-        &dev.client_bundler.resolver,
-    ) catch {
-        // bun i react@experimental react-dom@experimental react-server-dom-webpack@experimental react-refresh@experimental
+    dev.framework = dev.framework.resolve(&dev.server_bundler.resolver, &dev.client_bundler.resolver) catch {
         Output.errGeneric("Failed to resolve all imports required by the framework", .{});
         return error.FrameworkInitialization;
     };
 
-    dev.vm = VirtualMachine.initKit(.{
-        .allocator = bun.default_allocator,
-        .args = std.mem.zeroes(bun.Schema.Api.TransformOptions),
-    }) catch |err|
-        Output.panic("Failed to create Global object: {}", .{err});
-    dev.server_global = c.BakeCreateDevGlobal(dev, dev.vm.console);
-    dev.vm.global = dev.server_global.js();
-    dev.vm.regular_event_loop.global = dev.vm.global;
-    dev.vm.jsc = dev.vm.global.vm();
-    dev.vm.event_loop.ensureWaker();
+    errdefer dev.route_lookup.clearAndFree(allocator);
+    // errdefer dev.client_graph.deinit(allocator);
+    // errdefer dev.server_graph.deinit(allocator);
+
+    dev.vm.global = @ptrCast(dev.vm.global);
 
     dev.configuration_hash_key = hash_key: {
         var hash = std.hash.Wyhash.init(128);
@@ -296,8 +305,10 @@ pub fn init(options: Options) !*DevServer {
             hash.update(bun.Environment.git_sha_short);
         }
 
-        hash.update(dev.framework.entry_client);
-        hash.update(dev.framework.entry_server);
+        // TODO: hash router types
+        // hash.update(dev.framework.entry_client);
+        // hash.update(dev.framework.entry_server);
+
         if (dev.framework.server_components) |sc| {
             bun.writeAnyToHasher(&hash, true);
             bun.writeAnyToHasher(&hash, sc.separate_ssr_graph);
@@ -325,163 +336,147 @@ pub fn init(options: Options) !*DevServer {
         break :hash_key std.fmt.bytesToHex(std.mem.asBytes(&hash.final()), .lower);
     };
 
-    var has_fallback = false;
-
-    for (options.routes, 0..) |*route, i| {
-        app.any(route.pattern, *Route, route, onServerRequest);
-
-        route.dev = dev;
-        route.client_bundled_url = std.fmt.allocPrint(
-            allocator,
-            client_prefix ++ "/{d}.js",
-            .{i},
-        ) catch bun.outOfMemory();
-
-        if (bun.strings.eqlComptime(route.pattern, "/*"))
-            has_fallback = true;
+    // Add react fast refresh if needed. This is the first file on the client side,
+    // as it will be referred to by index.
+    if (dev.framework.react_fast_refresh) |rfr| {
+        assert(try dev.client_graph.insertStale(rfr.import_source, false) == IncrementalGraph(.client).react_refresh_index);
     }
 
-    app.get(client_prefix ++ "/:route", *DevServer, dev, onJsRequest);
-    app.get(asset_prefix ++ "/:asset", *DevServer, dev, onAssetRequest);
-    app.get(css_prefix ++ "/:asset", *DevServer, dev, onCssRequest);
-    app.get(internal_prefix ++ "/src/*", *DevServer, dev, onSrcRequest);
+    try dev.initServerRuntime();
 
-    app.ws(
-        internal_prefix ++ "/hmr",
-        dev,
-        0,
-        uws.WebSocketBehavior.Wrap(DevServer, HmrSocket, false).apply(.{}),
-    );
+    // Initialize the router
+    dev.router = router: {
+        var types = try std.ArrayListUnmanaged(FrameworkRouter.Type).initCapacity(allocator, options.framework.file_system_router_types.len);
+        errdefer types.deinit(allocator);
 
-    app.get(internal_prefix ++ "/incremental_visualizer", *DevServer, dev, onIncrementalVisualizer);
+        for (options.framework.file_system_router_types, 0..) |fsr, i| {
+            const joined_root = bun.path.joinAbs(dev.root, .auto, fsr.root);
+            const entry = dev.server_bundler.resolver.readDirInfoIgnoreError(joined_root) orelse
+                continue;
 
-    if (!has_fallback)
-        app.any("/*", void, {}, onFallbackRoute);
+            const server_file = try dev.server_graph.insertStaleExtra(fsr.entry_server, false, true);
+
+            try types.append(allocator, .{
+                .abs_root = bun.strings.withoutTrailingSlash(entry.abs_path),
+                .prefix = fsr.prefix,
+                .ignore_underscores = fsr.ignore_underscores,
+                .ignore_dirs = fsr.ignore_dirs,
+                .extensions = fsr.extensions,
+                .style = fsr.style,
+                .server_file = toOpaqueFileId(.server, server_file),
+                .client_file = if (fsr.entry_client) |client|
+                    toOpaqueFileId(.client, try dev.client_graph.insertStale(client, false)).toOptional()
+                else
+                    .none,
+                .server_file_string = .{},
+            });
 
-    // Some indices at the start of the graph are reserved for framework files.
-    {
-        dev.graph_safety_lock.lock();
-        defer dev.graph_safety_lock.unlock();
+            try dev.route_lookup.put(allocator, server_file, .{
+                .route_index = FrameworkRouter.Route.Index.init(@intCast(i)),
+                .should_recurse_when_visiting = true,
+            });
+        }
 
-        assert(try dev.client_graph.insertStale(dev.framework.entry_client, false) == IncrementalGraph(.client).framework_entry_point_index);
-        assert(try dev.server_graph.insertStale(dev.framework.entry_server, false) == IncrementalGraph(.server).framework_entry_point_index);
+        break :router try FrameworkRouter.initEmpty(types.items, allocator);
+    };
 
-        if (dev.framework.react_fast_refresh) |rfr| {
-            assert(try dev.client_graph.insertStale(rfr.import_source, false) == IncrementalGraph(.client).react_refresh_index);
-        }
+    // TODO: move pre-bundling to be one tick after server startup.
+    // this way the line saying the server is ready shows quicker
+    try dev.scanInitialRoutes();
 
-        try dev.client_graph.ensureStaleBitCapacity(true);
-        try dev.server_graph.ensureStaleBitCapacity(true);
+    if (bun.FeatureFlags.bake_debugging_features and options.dump_state_on_crash)
+        try bun.crash_handler.appendPreCrashHandler(DevServer, dev, dumpStateDueToCrash);
 
-        const client_files = dev.client_graph.bundled_files.values();
-        client_files[IncrementalGraph(.client).framework_entry_point_index.get()].flags.is_special_framework_file = true;
-    }
+    return dev;
+}
 
-    // Pre-bundle the framework code
-    {
-        // Since this will enter JavaScript to load code, ensure we have a lock.
-        const lock = dev.vm.jsc.getAPILock();
-        defer lock.release();
-
-        dev.bundle(&.{
-            BakeEntryPoint.init(dev.framework.entry_server, .server),
-            BakeEntryPoint.init(dev.framework.entry_client, .client),
-        }) catch |err| {
-            _ = &err; // autofix
-            bun.todoPanic(@src(), "handle error", .{});
-        };
-    }
+fn initServerRuntime(dev: *DevServer) !void {
+    const runtime = bun.String.static(bun.bake.getHmrRuntime(.server));
 
-    app.listenWithConfig(*DevServer, dev, onListen, options.listen_config);
+    const interface = c.BakeLoadInitialServerCode(
+        @ptrCast(dev.vm.global),
+        runtime,
+        if (dev.framework.server_components) |sc| sc.separate_ssr_graph else false,
+    ) catch |err| {
+        dev.vm.printErrorLikeObjectToConsole(dev.vm.global.takeException(err));
+        @panic("Server runtime failed to start. The above error is always a bug in Bun");
+    };
 
-    return dev;
+    if (!interface.isObject())
+        @panic("Internal assertion failure: expected interface from HMR runtime to be an object");
+    const fetch_function: JSValue = interface.get(dev.vm.global, "handleRequest") orelse
+        @panic("Internal assertion failure: expected interface from HMR runtime to contain handleRequest");
+    bun.assert(fetch_function.isCallable(dev.vm.jsc));
+    dev.server_fetch_function_callback = JSC.Strong.create(fetch_function, dev.vm.global);
+    const register_update = interface.get(dev.vm.global, "registerUpdate") orelse
+        @panic("Internal assertion failure: expected interface from HMR runtime to contain registerUpdate");
+    dev.server_register_update_callback = JSC.Strong.create(register_update, dev.vm.global);
+
+    fetch_function.ensureStillAlive();
+    register_update.ensureStillAlive();
 }
 
-fn deinit(dev: *DevServer) void {
-    const allocator = dev.allocator;
-    allocator.destroy(dev);
-    bun.todoPanic(@src(), "bake.DevServer.deinit()");
+/// Deferred one tick so that the server can be up faster
+fn scanInitialRoutes(dev: *DevServer) !void {
+    try dev.router.scanAll(
+        dev.allocator,
+        &dev.server_bundler.resolver,
+        FrameworkRouter.InsertionContext.wrap(DevServer, dev),
+    );
+
+    try dev.server_graph.ensureStaleBitCapacity(true);
+    try dev.client_graph.ensureStaleBitCapacity(true);
 }
 
-pub fn runLoopForever(dev: *DevServer) noreturn {
-    const lock = dev.vm.jsc.getAPILock();
-    defer lock.release();
+pub fn attachRoutes(dev: *DevServer, server: anytype) !void {
+    dev.server = bun.JSC.API.AnyServer.from(server);
+    const app = server.app.?;
 
-    while (true) {
-        dev.vm.tick();
-        dev.vm.eventLoop().autoTickActive();
+    // For this to work, the route handlers need to be augmented to use the comptime
+    // SSL parameter. It's worth considering removing the SSL boolean.
+    if (@TypeOf(app) == *uws.NewApp(true)) {
+        bun.todoPanic(@src(), "DevServer does not support SSL yet", .{});
     }
-}
 
-// uws handlers
+    app.get(client_prefix ++ "/:route", *DevServer, dev, onJsRequest);
+    app.get(asset_prefix ++ "/:asset", *DevServer, dev, onAssetRequest);
+    app.get(css_prefix ++ "/:asset", *DevServer, dev, onCssRequest);
+    app.get(internal_prefix ++ "/src/*", *DevServer, dev, onSrcRequest);
 
-fn onListen(ctx: *DevServer, maybe_listen: ?*App.ListenSocket) void {
-    const listen: *App.ListenSocket = maybe_listen orelse {
-        bun.todoPanic(@src(), "handle listen failure", .{});
-    };
+    app.ws(
+        internal_prefix ++ "/hmr",
+        dev,
+        0,
+        uws.WebSocketBehavior.Wrap(DevServer, HmrSocket, false).apply(.{}),
+    );
 
-    ctx.listener = listen;
-    ctx.address.port = @intCast(listen.getLocalPort());
+    app.get(internal_prefix ++ "/incremental_visualizer", *DevServer, dev, onIncrementalVisualizer);
 
-    Output.prettyErrorln("--\\> <green>http://{s}:{d}<r>\n", .{
-        bun.span(ctx.address.hostname),
-        ctx.address.port,
-    });
-    Output.flush();
+    app.any("/*", *DevServer, dev, onRequest);
+}
+
+pub fn deinit(dev: *DevServer) void {
+    const allocator = dev.allocator;
+    if (dev.has_pre_crash_handler)
+        bun.crash_handler.removePreCrashHandler(dev);
+    allocator.destroy(dev);
+    bun.todoPanic(@src(), "bake.DevServer.deinit()", .{});
 }
 
 fn onJsRequest(dev: *DevServer, req: *Request, resp: *Response) void {
-    const route = route: {
+    const route_bundle = route: {
         const route_id = req.parameter(0);
         if (!bun.strings.hasSuffixComptime(route_id, ".js"))
             return req.setYield(true);
-        const i = std.fmt.parseInt(u16, route_id[0 .. route_id.len - 3], 10) catch
+        if (!bun.strings.hasPrefixComptime(route_id, "route."))
             return req.setYield(true);
-        if (i >= dev.routes.len)
+        const i = parseHexToInt(u64, route_id["route.".len .. route_id.len - ".js".len]) orelse
+            return req.setYield(true);
+        break :route dev.route_js_payloads.get(i) orelse
             return req.setYield(true);
-        break :route &dev.routes[i];
     };
 
-    const js_source = route.client_bundle orelse code: {
-        if (route.server_state == .unqueued) {
-            dev.bundleRouteFirstTime(route);
-        }
-
-        switch (route.server_state) {
-            .unqueued => bun.assertWithLocation(false, @src()),
-            .possible_bundling_failures => {
-                if (dev.bundling_failures.count() > 0) {
-                    resp.corked(sendSerializedFailures, .{
-                        dev,
-                        resp,
-                        dev.bundling_failures.keys(),
-                        .bundler,
-                    });
-                    return;
-                } else {
-                    route.server_state = .loaded;
-                }
-            },
-            .evaluation_failure => {
-                resp.corked(sendSerializedFailures, .{
-                    dev,
-                    resp,
-                    &.{route.evaluate_failure orelse @panic("missing error")},
-                    .evaluation,
-                });
-                return;
-            },
-            .loaded => {},
-        }
-
-        // TODO: there can be stale files in this if you request an asset after
-        // a watch but before the bundle task starts.
-
-        const out = dev.generateClientBundle(route) catch bun.outOfMemory();
-        route.client_bundle = out;
-        break :code out;
-    };
-    sendTextFile(js_source, MimeType.javascript.value, resp);
+    dev.ensureRouteIsBundled(route_bundle, .js_payload, req, resp) catch bun.outOfMemory();
 }
 
 fn onAssetRequest(dev: *DevServer, req: *Request, resp: *Response) void {
@@ -515,6 +510,12 @@ fn onCssRequest(dev: *DevServer, req: *Request, resp: *Response) void {
     sendTextFile(css, MimeType.css.value, resp);
 }
 
+fn parseHexToInt(comptime T: type, slice: []const u8) ?T {
+    var out: [@sizeOf(T)]u8 = undefined;
+    assert((std.fmt.hexToBytes(&out, slice) catch return null).len == @sizeOf(T));
+    return @bitCast(out);
+}
+
 fn onIncrementalVisualizer(_: *DevServer, _: *Request, resp: *Response) void {
     resp.corked(onIncrementalVisualizerCorked, .{resp});
 }
@@ -528,38 +529,65 @@ fn onIncrementalVisualizerCorked(resp: *Response) void {
     resp.end(code, false);
 }
 
-/// `route.server_state` must be `.unenqueued`
-fn bundleRouteFirstTime(dev: *DevServer, route: *Route) void {
-    if (Environment.allow_assert) switch (route.server_state) {
-        .unqueued => {},
-        .possible_bundling_failures => unreachable, // should watch affected files and bundle on save
-        .evaluation_failure => unreachable, // bundling again wont fix this issue
-        .loaded => unreachable, // should not be bundling since it already passed
-    };
-
-    if (dev.bundle(&.{
-        BakeEntryPoint.route(
-            route.entry_point,
-            Route.Index.init(@intCast(bun.indexOfPointerInSlice(Route, dev.routes, route))),
-        ),
-    })) |_| {
-        route.server_state = .loaded;
-    } else |err| switch (err) {
-        error.OutOfMemory => bun.outOfMemory(),
-        error.BuildFailed => assert(route.server_state == .possible_bundling_failures),
-        error.ServerLoadFailed => route.server_state = .evaluation_failure,
-    }
-}
+fn ensureRouteIsBundled(
+    dev: *DevServer,
+    route_index: Route.Index,
+    kind: DeferredRequest.Data.Tag,
+    req: *Request,
+    resp: *Response,
+) bun.OOM!void {
+    const bundle_index = if (dev.router.routePtr(route_index).bundle.unwrap()) |bundle_index|
+        bundle_index
+    else
+        try dev.insertRouteBundle(route_index);
+
+    switch (dev.routeBundlePtr(bundle_index).server_state) {
+        .unqueued => {
+            const server_file_names = dev.server_graph.bundled_files.keys();
+            const client_file_names = dev.client_graph.bundled_files.keys();
+
+            var sfa = std.heap.stackFallback(4096, dev.allocator);
+            const temp_alloc = sfa.get();
+
+            var entry_points = std.ArrayList(BakeEntryPoint).init(temp_alloc);
+            defer entry_points.deinit();
+
+            // Build a list of all files that have not yet been bundled.
+            var route = dev.router.routePtr(route_index);
+            const router_type = dev.router.typePtr(route.type);
+            try dev.appendOpaqueEntryPoint(server_file_names, &entry_points, .server, router_type.server_file);
+            try dev.appendOpaqueEntryPoint(client_file_names, &entry_points, .client, router_type.client_file);
+            try dev.appendOpaqueEntryPoint(server_file_names, &entry_points, .server, route.file_page);
+            try dev.appendOpaqueEntryPoint(server_file_names, &entry_points, .server, route.file_layout);
+            while (route.parent.unwrap()) |parent_index| {
+                route = dev.router.routePtr(parent_index);
+                try dev.appendOpaqueEntryPoint(server_file_names, &entry_points, .server, route.file_layout);
+            }
 
-fn onServerRequest(route: *Route, req: *Request, resp: *Response) void {
-    const dev = route.dev;
+            if (entry_points.items.len == 0) {
+                @panic("TODO: trace graph for possible errors, so DevServer knows what state this should go to");
+            }
 
-    if (route.server_state == .unqueued) {
-        dev.bundleRouteFirstTime(route);
+            const route_bundle = dev.routeBundlePtr(bundle_index);
+            if (dev.bundle(entry_points.items)) |_| {
+                route_bundle.server_state = .loaded;
+            } else |err| switch (err) {
+                error.OutOfMemory => bun.outOfMemory(),
+                error.BuildFailed => assert(route_bundle.server_state == .possible_bundling_failures),
+                error.ServerLoadFailed => route_bundle.server_state = .evaluation_failure,
+            }
+        },
+        .bundling => {
+            const prepared = dev.server.?.DebugHTTPServer.prepareJsRequestContext(req, resp) orelse
+                return;
+            _ = prepared;
+            @panic("TODO: Async Bundler");
+        },
+        else => {},
     }
-
-    switch (route.server_state) {
-        .unqueued => bun.assertWithLocation(false, @src()),
+    switch (dev.routeBundlePtr(bundle_index).server_state) {
+        .unqueued => unreachable,
+        .bundling => @panic("TODO: Async Bundler"),
         .possible_bundling_failures => {
             // TODO: perform a graph trace to find just the errors that are needed
             if (dev.bundling_failures.count() > 0) {
@@ -571,14 +599,14 @@ fn onServerRequest(route: *Route, req: *Request, resp: *Response) void {
                 });
                 return;
             } else {
-                route.server_state = .loaded;
+                dev.routeBundlePtr(bundle_index).server_state = .loaded;
             }
         },
         .evaluation_failure => {
             resp.corked(sendSerializedFailures, .{
                 dev,
                 resp,
-                (&(route.evaluate_failure orelse @panic("missing error")))[0..1],
+                (&(dev.routeBundlePtr(bundle_index).evaluate_failure orelse @panic("missing error")))[0..1],
                 .evaluation,
             });
             return;
@@ -586,101 +614,94 @@ fn onServerRequest(route: *Route, req: *Request, resp: *Response) void {
         .loaded => {},
     }
 
-    // TODO: this does not move the body, reuse memory, and many other things
-    // that server.zig does.
-    const url_bun_string = bun.String.init(req.url());
-    defer url_bun_string.deref();
-
-    const headers = JSC.FetchHeaders.createFromUWS(req);
-    const request_object = JSC.WebCore.Request.init(
-        url_bun_string,
-        headers,
-        dev.vm.initRequestBodyValue(.Null) catch bun.outOfMemory(),
-        bun.http.Method.which(req.method()) orelse .GET,
-    ).new();
-
-    const js_request = request_object.toJS(dev.server_global.js());
-
-    const global = dev.server_global.js();
+    switch (kind) {
+        .server_handler => dev.onRequestWithBundle(bundle_index, .{ .stack = req }, resp),
+        .js_payload => dev.onJsRequestWithBundle(bundle_index, resp),
+    }
+}
 
+fn onRequestWithBundle(
+    dev: *DevServer,
+    route_bundle_index: RouteBundle.Index,
+    req: bun.JSC.API.SavedRequest.Union,
+    resp: *Response,
+) void {
     const server_request_callback = dev.server_fetch_function_callback.get() orelse
         unreachable; // did not bundle
 
-    var result = server_request_callback.call(
-        global,
-        .undefined,
-        &.{
-            // req
-            js_request,
-            // routeModuleId
-            route.module_name_string.get() orelse str: {
-                const js = bun.String.createUTF8(
-                    bun.path.relative(dev.cwd, route.entry_point),
-                ).toJS(dev.server_global.js());
-                route.module_name_string = JSC.Strong.create(js, dev.server_global.js());
+    const route_bundle = dev.routeBundlePtr(route_bundle_index);
+
+    const router_type = dev.router.typePtr(dev.router.routePtr(route_bundle.route).type);
+
+    dev.server.?.onRequestFromSaved(
+        req,
+        resp,
+        server_request_callback,
+        4,
+        .{
+            // routerTypeMain
+            router_type.server_file_string.get() orelse str: {
+                const name = dev.server_graph.bundled_files.keys()[fromOpaqueFileId(.server, router_type.server_file).get()];
+                const str = bun.String.createUTF8(name);
+                defer str.deref();
+                const js = str.toJS(dev.vm.global);
+                router_type.server_file_string = JSC.Strong.create(js, dev.vm.global);
                 break :str js;
             },
+            // routeModules
+            route_bundle.cached_module_list.get() orelse arr: {
+                const global = dev.vm.global;
+                const keys = dev.server_graph.bundled_files.keys();
+                var n: usize = 1;
+                var route = dev.router.routePtr(route_bundle.route);
+                while (true) {
+                    if (route.file_layout != .none) n += 1;
+                    route = dev.router.routePtr(route.parent.unwrap() orelse break);
+                }
+                const arr = JSValue.createEmptyArray(global, n);
+                route = dev.router.routePtr(route_bundle.route);
+                var route_name = bun.String.createUTF8(dev.relativePath(keys[fromOpaqueFileId(.server, route.file_page.unwrap().?).get()]));
+                arr.putIndex(global, 0, route_name.transferToJS(global));
+                n = 1;
+                while (true) {
+                    if (route.file_layout.unwrap()) |layout| {
+                        var layout_name = bun.String.createUTF8(dev.relativePath(keys[fromOpaqueFileId(.server, layout).get()]));
+                        arr.putIndex(global, @intCast(n), layout_name.transferToJS(global));
+                        n += 1;
+                    }
+                    route = dev.router.routePtr(route.parent.unwrap() orelse break);
+                }
+                route_bundle.cached_module_list = JSC.Strong.create(arr, global);
+                break :arr arr;
+            },
             // clientId
-            route.client_bundle_url_value.get() orelse str: {
-                const js = bun.String.createUTF8(route.client_bundled_url).toJS(global);
-                route.client_bundle_url_value = JSC.Strong.create(js, dev.server_global.js());
+            route_bundle.cached_client_bundle_url.get() orelse str: {
+                const id = std.crypto.random.int(u64);
+                dev.route_js_payloads.put(dev.allocator, id, route_bundle.route) catch bun.outOfMemory();
+                const str = bun.String.createFormat(client_prefix ++ "/route.{}.js", .{std.fmt.fmtSliceHexLower(std.mem.asBytes(&id))}) catch bun.outOfMemory();
+                defer str.deref();
+                const js = str.toJS(dev.vm.global);
+                route_bundle.cached_client_bundle_url = JSC.Strong.create(js, dev.vm.global);
                 break :str js;
             },
             // styles
-            route.css_file_array.get() orelse arr: {
-                const js = dev.generateCssList(route) catch bun.outOfMemory();
-                route.css_file_array = JSC.Strong.create(js, dev.server_global.js());
+            route_bundle.cached_css_file_array.get() orelse arr: {
+                const js = dev.generateCssList(route_bundle) catch bun.outOfMemory();
+                route_bundle.cached_css_file_array = JSC.Strong.create(js, dev.vm.global);
                 break :arr js;
             },
         },
-    ) catch |err| {
-        const exception = global.takeException(err);
-        dev.vm.printErrorLikeObjectToConsole(exception);
-        // const fail = try SerializedFailure.initFromJs(.none, exception);
-        // defer fail.deinit();
-        // dev.sendSerializedFailures(resp, &.{fail}, .runtime);
-        dev.sendStubErrorMessage(route, resp, exception);
-        return;
-    };
-
-    if (result.asAnyPromise()) |promise| {
-        dev.vm.waitForPromise(promise);
-        switch (promise.unwrap(dev.vm.jsc, .mark_handled)) {
-            .pending => unreachable, // was waited for
-            .fulfilled => |r| result = r,
-            .rejected => |exception| {
-                dev.vm.printErrorLikeObjectToConsole(exception);
-                dev.sendStubErrorMessage(route, resp, exception);
-                // const fail = try SerializedFailure.initFromJs(.none, e);
-                // defer fail.deinit();
-                // dev.sendSerializedFailures(resp, &.{fail}, .runtime);
-                return;
-            },
-        }
-    }
-
-    // TODO: This interface and implementation is very poor. It is fine as
-    // the runtime currently emulates returning a `new Response`
-    //
-    // It probably should use code from `server.zig`, but most importantly it should
-    // not have a tie to DevServer, but instead be generic with a context structure
-    // containing just a *uws.App, *JSC.EventLoop, and JSValue response object.
-    //
-    // This would allow us to support all of the nice things `new Response` allows
-
-    bun.assert(result.isString());
-    const bun_string = result.toBunString(dev.server_global.js());
-    defer bun_string.deref();
-    if (bun_string.tag == .Dead) {
-        bun.outOfMemory();
-    }
-
-    const utf8 = bun_string.toUTF8(dev.allocator);
-    defer utf8.deinit();
+    );
+}
 
-    resp.writeStatus("200 OK");
-    resp.writeHeader("Content-Type", MimeType.html.value);
-    resp.end(utf8.slice(), true); // TODO: You should never call res.end(huge buffer)
+pub fn onJsRequestWithBundle(dev: *DevServer, bundle_index: RouteBundle.Index, resp: *Response) void {
+    const route_bundle = dev.routeBundlePtr(bundle_index);
+    const code = route_bundle.client_bundle orelse code: {
+        const code = dev.generateClientBundle(route_bundle) catch bun.outOfMemory();
+        route_bundle.client_bundle = code;
+        break :code code;
+    };
+    sendTextFile(code, MimeType.javascript.value, resp);
 }
 
 pub fn onSrcRequest(dev: *DevServer, req: *uws.Request, resp: *App.Response) void {
@@ -726,6 +747,15 @@ fn bundle(dev: *DevServer, files: []const BakeEntryPoint) BundleError!void {
 
     assert(files.len > 0);
 
+    const bundle_file_list = bun.Output.Scoped(.bundle_file_list, false);
+
+    if (bundle_file_list.isVisible()) {
+        bundle_file_list.log("Start bundle {d} files", .{files.len});
+        for (files) |f| {
+            bundle_file_list.log("- {s} (.{s})", .{ f.path, @tagName(f.graph) });
+        }
+    }
+
     var heap = try ThreadlocalArena.init();
     defer heap.deinit();
 
@@ -804,82 +834,43 @@ fn bundle(dev: *DevServer, files: []const BakeEntryPoint) BundleError!void {
     const is_first_server_chunk = !dev.server_fetch_function_callback.has();
 
     if (dev.server_graph.current_chunk_len > 0) {
-        const server_bundle = try dev.server_graph.takeBundle(if (is_first_server_chunk) .initial_response else .hmr_chunk);
+        const server_bundle = try dev.server_graph.takeBundle(
+            if (is_first_server_chunk) .initial_response else .hmr_chunk,
+            "",
+        );
         defer dev.allocator.free(server_bundle);
 
-        if (is_first_server_chunk) {
-            const server_code = c.BakeLoadInitialServerCode(dev.server_global, bun.String.createLatin1(server_bundle)) catch |err| {
-                dev.vm.printErrorLikeObjectToConsole(dev.server_global.js().takeException(err));
-                {
-                    // TODO: document the technical reasons this should not be allowed to fail
-                    bun.todoPanic(@src(), "First Server Load Fails. This should become a bundler bug.", .{});
-                }
-                _ = &err; // autofix
-                // fail.* = Failure.fromJSServerLoad(dev.server_global.js().takeException(err), dev.server_global.js());
-                return error.ServerLoadFailed;
-            };
-            dev.vm.waitForPromise(.{ .internal = server_code.promise });
-
-            switch (server_code.promise.unwrap(dev.vm.jsc, .mark_handled)) {
-                .pending => unreachable, // promise is settled
-                .rejected => |err| {
-                    dev.vm.printErrorLikeObjectToConsole(err);
-                    {
-                        bun.todoPanic(@src(), "First Server Load Fails. This should become a bundler bug.", .{});
-                    }
-                    _ = &err; // autofix
-                    // fail.* = Failure.fromJSServerLoad(err, dev.server_global.js());
-                    return error.ServerLoadFailed;
-                },
-                .fulfilled => |v| bun.assert(v == .undefined),
-            }
-
-            const default_export = c.BakeGetDefaultExportFromModule(dev.server_global.js(), server_code.key.toJS());
-            if (!default_export.isObject())
-                @panic("Internal assertion failure: expected interface from HMR runtime to be an object");
-            const fetch_function: JSValue = default_export.get(dev.server_global.js(), "handleRequest") orelse
-                @panic("Internal assertion failure: expected interface from HMR runtime to contain handleRequest");
-            bun.assert(fetch_function.isCallable(dev.vm.jsc));
-            dev.server_fetch_function_callback = JSC.Strong.create(fetch_function, dev.server_global.js());
-            const register_update = default_export.get(dev.server_global.js(), "registerUpdate") orelse
-                @panic("Internal assertion failure: expected interface from HMR runtime to contain registerUpdate");
-            dev.server_register_update_callback = JSC.Strong.create(register_update, dev.server_global.js());
-
-            fetch_function.ensureStillAlive();
-            register_update.ensureStillAlive();
-        } else {
-            const server_modules = c.BakeLoadServerHmrPatch(dev.server_global, bun.String.createLatin1(server_bundle)) catch |err| {
-                // No user code has been evaluated yet, since everything is to
-                // be wrapped in a function clousure. This means that the likely
-                // error is going to be a syntax error, or other mistake in the
-                // bundler.
-                dev.vm.printErrorLikeObjectToConsole(dev.server_global.js().takeException(err));
-                @panic("Error thrown while evaluating server code. This is always a bug in the bundler.");
-            };
-            const errors = dev.server_register_update_callback.get().?.call(
-                dev.server_global.js(),
-                dev.server_global.js().toJSValue(),
-                &.{
-                    server_modules,
-                    dev.makeArrayForServerComponentsPatch(dev.server_global.js(), dev.incremental_result.client_components_added.items),
-                    dev.makeArrayForServerComponentsPatch(dev.server_global.js(), dev.incremental_result.client_components_removed.items),
-                },
-            ) catch |err| {
-                // One module replacement error should NOT prevent follow-up
-                // module replacements to fail. It is the HMR runtime's
-                // responsibility to collect all module load errors, and
-                // bubble them up.
-                dev.vm.printErrorLikeObjectToConsole(dev.server_global.js().takeException(err));
-                @panic("Error thrown in Hot-module-replacement code. This is always a bug in the HMR runtime.");
-            };
-            _ = errors; // TODO:
-        }
+        const server_modules = c.BakeLoadServerHmrPatch(@ptrCast(dev.vm.global), bun.String.createLatin1(server_bundle)) catch |err| {
+            // No user code has been evaluated yet, since everything is to
+            // be wrapped in a function clousure. This means that the likely
+            // error is going to be a syntax error, or other mistake in the
+            // bundler.
+            dev.vm.printErrorLikeObjectToConsole(dev.vm.global.takeException(err));
+            @panic("Error thrown while evaluating server code. This is always a bug in the bundler.");
+        };
+        const errors = dev.server_register_update_callback.get().?.call(
+            dev.vm.global,
+            dev.vm.global.toJSValue(),
+            &.{
+                server_modules,
+                dev.makeArrayForServerComponentsPatch(dev.vm.global, dev.incremental_result.client_components_added.items),
+                dev.makeArrayForServerComponentsPatch(dev.vm.global, dev.incremental_result.client_components_removed.items),
+            },
+        ) catch |err| {
+            // One module replacement error should NOT prevent follow-up
+            // module replacements to fail. It is the HMR runtime's
+            // responsibility to collect all module load errors, and
+            // bubble them up.
+            dev.vm.printErrorLikeObjectToConsole(dev.vm.global.takeException(err));
+            @panic("Error thrown in Hot-module-replacement code. This is always a bug in the HMR runtime.");
+        };
+        _ = errors; // TODO:
     }
 
     const css_chunks = bundle_result.cssChunks();
     if ((dev.client_graph.current_chunk_len > 0 or
         css_chunks.len > 0) and
-        dev.app.num_subscribers(HmrSocket.global_topic) > 0)
+        dev.numSubscribers(HmrSocket.global_topic) > 0)
     {
         var sfb2 = std.heap.stackFallback(65536, bun.default_allocator);
         var payload = std.ArrayList(u8).initCapacity(sfb2.get(), 65536) catch
@@ -902,9 +893,9 @@ fn bundle(dev: *DevServer, files: []const BakeEntryPoint) BundleError!void {
         }
 
         if (dev.client_graph.current_chunk_len > 0)
-            try dev.client_graph.takeBundleToList(.hmr_chunk, &payload);
+            try dev.client_graph.takeBundleToList(.hmr_chunk, &payload, "");
 
-        _ = dev.app.publish(HmrSocket.global_topic, payload.items, .binary, true);
+        dev.publish(HmrSocket.global_topic, payload.items, .binary);
     }
 
     if (dev.incremental_result.failures_added.items.len > 0) {
@@ -954,15 +945,18 @@ fn indexFailures(dev: *DevServer) !void {
             }
         }
 
-        for (dev.incremental_result.routes_affected.items) |route_index| {
-            const route = &dev.routes[route_index.get()];
-            route.server_state = .possible_bundling_failures;
+        {
+            @panic("TODO: revive");
         }
+        // for (dev.incremental_result.routes_affected.items) |route_index| {
+        //     const route = &dev.routes[route_index.get()];
+        //     route.server_state = .possible_bundling_failures;
+        // }
 
-        _ = dev.app.publish(HmrSocket.global_topic, payload.items, .binary, false);
+        dev.publish(HmrSocket.global_topic, payload.items, .binary);
     } else if (dev.incremental_result.failures_removed.items.len > 0) {
         if (dev.bundling_failures.count() == 0) {
-            _ = dev.app.publish(HmrSocket.global_topic, &.{MessageId.errors_cleared.char()}, .binary, false);
+            dev.publish(HmrSocket.global_topic, &.{MessageId.errors_cleared.char()}, .binary);
             for (dev.incremental_result.failures_removed.items) |removed| {
                 removed.deinit();
             }
@@ -979,7 +973,7 @@ fn indexFailures(dev: *DevServer) !void {
                 removed.deinit();
             }
 
-            _ = dev.app.publish(HmrSocket.global_topic, payload.items, .binary, false);
+            dev.publish(HmrSocket.global_topic, payload.items, .binary);
         }
     }
 
@@ -988,9 +982,9 @@ fn indexFailures(dev: *DevServer) !void {
 
 /// Used to generate the entry point. Unlike incremental patches, this always
 /// contains all needed files for a route.
-fn generateClientBundle(dev: *DevServer, route: *Route) bun.OOM![]const u8 {
-    assert(route.client_bundle == null);
-    assert(route.server_state == .loaded); // page is unfit to load
+fn generateClientBundle(dev: *DevServer, route_bundle: *RouteBundle) bun.OOM![]const u8 {
+    assert(route_bundle.client_bundle == null);
+    assert(route_bundle.server_state == .loaded); // page is unfit to load
 
     dev.graph_safety_lock.lock();
     defer dev.graph_safety_lock.unlock();
@@ -1008,31 +1002,20 @@ fn generateClientBundle(dev: *DevServer, route: *Route) bun.OOM![]const u8 {
 
     // Run tracing
     dev.client_graph.reset();
+    try dev.traceAllRouteImports(route_bundle, .{ .find_client_modules = true });
 
-    // Framework entry point is always needed.
-    try dev.client_graph.traceImports(
-        IncrementalGraph(.client).framework_entry_point_index,
-        .{ .find_client_modules = true },
-    );
-
-    // If react fast refresh is enabled, it will be imported by the runtime instantly.
-    if (dev.framework.react_fast_refresh != null) {
-        try dev.client_graph.traceImports(IncrementalGraph(.client).react_refresh_index, .{ .find_client_modules = true });
-    }
+    const client_file = dev.router.typePtr(dev.router.routePtr(route_bundle.route).type).client_file.unwrap() orelse
+        @panic("No client side entrypoint in client bundle");
 
-    // Trace the route to the client components
-    try dev.server_graph.traceImports(
-        route.server_file.unwrap() orelse
-            Output.panic("File index for route not present", .{}),
-        .{ .find_client_modules = true },
+    return dev.client_graph.takeBundle(
+        .initial_response,
+        dev.relativePath(dev.client_graph.bundled_files.keys()[fromOpaqueFileId(.client, client_file).get()]),
     );
-
-    return dev.client_graph.takeBundle(.initial_response);
 }
 
-fn generateCssList(dev: *DevServer, route: *Route) bun.OOM!JSC.JSValue {
-    if (!Environment.allow_assert) assert(!route.css_file_array.has());
-    assert(route.server_state == .loaded); // page is unfit to load
+fn generateCssList(dev: *DevServer, route_bundle: *RouteBundle) bun.OOM!JSC.JSValue {
+    if (Environment.allow_assert) assert(!route_bundle.cached_css_file_array.has());
+    assert(route_bundle.server_state == .loaded); // page is unfit to load
 
     dev.graph_safety_lock.lock();
     defer dev.graph_safety_lock.unlock();
@@ -1049,36 +1032,48 @@ fn generateCssList(dev: *DevServer, route: *Route) bun.OOM!JSC.JSValue {
 
     // Run tracing
     dev.client_graph.reset();
-
-    // Framework entry point is allowed to include its own CSS
-    try dev.client_graph.traceImports(
-        IncrementalGraph(.client).framework_entry_point_index,
-        .{ .find_css = true },
-    );
-
-    // Trace the route to the css files
-    try dev.server_graph.traceImports(
-        route.server_file.unwrap() orelse
-            Output.panic("File index for route not present", .{}),
-        .{ .find_css = true },
-    );
+    try dev.traceAllRouteImports(route_bundle, .{ .find_css = true });
 
     const names = dev.client_graph.current_css_files.items;
-    const arr = JSC.JSArray.createEmpty(dev.server_global.js(), names.len);
+    const arr = JSC.JSArray.createEmpty(dev.vm.global, names.len);
     for (names, 0..) |item, i| {
         const str = bun.String.createUTF8(item);
         defer str.deref();
-        arr.putIndex(dev.server_global.js(), @intCast(i), str.toJS(dev.server_global.js()));
+        arr.putIndex(dev.vm.global, @intCast(i), str.toJS(dev.vm.global));
     }
     return arr;
 }
 
+fn traceAllRouteImports(dev: *DevServer, route_bundle: *RouteBundle, goal: TraceImportGoal) !void {
+    var route = dev.router.routePtr(route_bundle.route);
+    const router_type = dev.router.typePtr(route.type);
+
+    // Both framework entry points are considered
+    try dev.server_graph.traceImports(fromOpaqueFileId(.server, router_type.server_file), .{ .find_css = true });
+    if (router_type.client_file.unwrap()) |id| {
+        try dev.client_graph.traceImports(fromOpaqueFileId(.client, id), goal);
+    }
+
+    // The route file is considered
+    if (route.file_page.unwrap()) |id| {
+        try dev.server_graph.traceImports(fromOpaqueFileId(.server, id), goal);
+    }
+
+    // For all parents, the layout is considered
+    while (true) {
+        if (route.file_layout.unwrap()) |id| {
+            try dev.server_graph.traceImports(fromOpaqueFileId(.server, id), goal);
+        }
+        route = dev.router.routePtr(route.parent.unwrap() orelse break);
+    }
+}
+
 fn makeArrayForServerComponentsPatch(dev: *DevServer, global: *JSC.JSGlobalObject, items: []const IncrementalGraph(.server).FileIndex) JSValue {
     if (items.len == 0) return .null;
     const arr = JSC.JSArray.createEmpty(global, items.len);
     const names = dev.server_graph.bundled_files.keys();
     for (items, 0..) |item, i| {
-        const str = bun.String.createUTF8(bun.path.relative(dev.cwd, names[item.get()]));
+        const str = bun.String.createUTF8(dev.relativePath(names[item.get()]));
         defer str.deref();
         arr.putIndex(global, @intCast(i), str.toJS(global));
     }
@@ -1253,7 +1248,7 @@ pub fn handleParseTaskFailure(
 ) bun.OOM!void {
     // Print each error only once
     Output.prettyErrorln("<red><b>Errors while bundling '{s}':<r>", .{
-        bun.path.relative(dev.cwd, abs_path),
+        dev.relativePath(abs_path),
     });
     Output.flush();
     log.print(Output.errorWriter()) catch {};
@@ -1287,10 +1282,75 @@ pub fn isFileCached(dev: *DevServer, path: []const u8, side: bake.Graph) ?CacheE
     }
 }
 
-fn onFallbackRoute(_: void, _: *Request, resp: *Response) void {
+fn appendOpaqueEntryPoint(
+    dev: *DevServer,
+    file_names: [][]const u8,
+    entry_points: *std.ArrayList(BakeEntryPoint),
+    comptime side: bake.Side,
+    optional_id: anytype,
+) !void {
+    const file = switch (@TypeOf(optional_id)) {
+        OpaqueFileId.Optional => optional_id.unwrap() orelse return,
+        OpaqueFileId => optional_id,
+        else => @compileError("invalid type here"),
+    };
+
+    const file_index = fromOpaqueFileId(side, file);
+    if (switch (side) {
+        .server => dev.server_graph.stale_files.isSet(file_index.get()),
+        .client => dev.client_graph.stale_files.isSet(file_index.get()),
+    }) {
+        try entry_points.append(.{
+            .path = file_names[file_index.get()],
+            .graph = switch (side) {
+                .server => .server,
+                .client => .client,
+            },
+        });
+    }
+}
+
+pub fn routeBundlePtr(dev: *DevServer, idx: RouteBundle.Index) *RouteBundle {
+    return &dev.route_bundles.items[idx.get()];
+}
+
+fn onRequest(dev: *DevServer, req: *Request, resp: *Response) void {
+    var params: FrameworkRouter.MatchedParams = undefined;
+    if (dev.router.matchSlow(req.url(), &params)) |route_index| {
+        dev.ensureRouteIsBundled(route_index, .server_handler, req, resp) catch bun.outOfMemory();
+        return;
+    }
+
     sendBuiltInNotFound(resp);
 }
 
+fn insertRouteBundle(dev: *DevServer, route: Route.Index) !RouteBundle.Index {
+    const full_pattern = full_pattern: {
+        var buf = bake.PatternBuffer.empty;
+        var current: *Route = dev.router.routePtr(route);
+        while (true) {
+            buf.prependPart(current.part);
+            current = dev.router.routePtr(current.parent.unwrap() orelse break);
+        }
+        break :full_pattern try dev.allocator.dupe(u8, buf.slice());
+    };
+    errdefer dev.allocator.free(full_pattern);
+
+    try dev.route_bundles.append(dev.allocator, .{
+        .route = route,
+        .server_state = .unqueued,
+        .full_pattern = full_pattern,
+        .client_bundle = null,
+        .evaluate_failure = null,
+        .cached_module_list = .{},
+        .cached_client_bundle_url = .{},
+        .cached_css_file_array = .{},
+    });
+    const bundle_index = RouteBundle.Index.init(@intCast(dev.route_bundles.items.len - 1));
+    dev.router.routePtr(route).bundle = bundle_index.toOptional();
+    return bundle_index;
+}
+
 fn sendTextFile(code: []const u8, content_type: []const u8, resp: *Response) void {
     if (code.len == 0) {
         resp.writeStatus("202 No Content");
@@ -1376,7 +1436,7 @@ fn sendBuiltInNotFound(resp: *Response) void {
     resp.end(message, true);
 }
 
-fn sendStubErrorMessage(dev: *DevServer, route: *Route, resp: *Response, err: JSValue) void {
+fn sendStubErrorMessage(dev: *DevServer, route: *RouteBundle, resp: *Response, err: JSValue) void {
     var sfb = std.heap.stackFallback(65536, dev.allocator);
     var a = std.ArrayList(u8).initCapacity(sfb.get(), 65536) catch bun.outOfMemory();
 
@@ -1389,7 +1449,7 @@ fn sendStubErrorMessage(dev: *DevServer, route: *Route, resp: *Response, err: JS
     resp.end(a.items, true); // TODO: "You should never call res.end(huge buffer)"
 }
 
-const FileKind = enum {
+const FileKind = enum(u2) {
     /// Files that failed to bundle or do not exist on disk will appear in the
     /// graph as "unknown".
     unknown,
@@ -1587,8 +1647,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
         /// An index into `bundled_files`, `stale_files`, `first_dep`, `first_import`, or `affected_by_trace`
         /// Top bits cannot be relied on due to `SerializedFailure.Owner.Packed`
         pub const FileIndex = bun.GenericIndex(u30, File);
-        pub const framework_entry_point_index = FileIndex.init(0);
-        pub const react_refresh_index = if (side == .client) FileIndex.init(1);
+        pub const react_refresh_index = if (side == .client) FileIndex.init(0);
 
         /// An index into `edges`
         const EdgeIndex = bun.GenericIndex(u32, Edge);
@@ -1638,8 +1697,8 @@ pub fn IncrementalGraph(side: bake.Side) type {
             g.current_chunk_len += code.len;
 
             // Dump to filesystem if enabled
-            if (dev.dump_dir) |dump_dir| {
-                const cwd = dev.cwd;
+            if (bun.FeatureFlags.bake_debugging_features) if (dev.dump_dir) |dump_dir| {
+                const cwd = dev.root;
                 var a: bun.PathBuffer = undefined;
                 var b: [bun.MAX_PATH_BYTES * 2]u8 = undefined;
                 const rel_path = bun.path.relativeBufZ(&a, cwd, abs_path);
@@ -1653,7 +1712,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
                     bun.handleErrorReturnTrace(err, @errorReturnTrace());
                     Output.warn("Could not dump bundle: {}", .{err});
                 };
-            }
+            };
 
             const gop = try g.bundled_files.getOrPut(dev.allocator, abs_path);
             const file_index = FileIndex.init(@intCast(gop.index));
@@ -1932,11 +1991,6 @@ pub fn IncrementalGraph(side: bake.Side) type {
             stop_at_boundary,
             no_stop,
         };
-        const TraceImportGoal = struct {
-            // gts: *GraphTraceState,
-            find_css: bool = false,
-            find_client_modules: bool = false,
-        };
 
         fn traceDependencies(g: *@This(), file_index: FileIndex, trace_kind: TraceDependencyKind) !void {
             g.owner().graph_safety_lock.assertLocked();
@@ -2061,16 +2115,10 @@ pub fn IncrementalGraph(side: bake.Side) type {
         /// Never takes ownership of `abs_path`
         /// Marks a chunk but without any content. Used to track dependencies to files that don't exist.
         pub fn insertStale(g: *@This(), abs_path: []const u8, is_ssr_graph: bool) bun.OOM!FileIndex {
-            return g.insertStaleExtra(abs_path, is_ssr_graph, false, {});
+            return g.insertStaleExtra(abs_path, is_ssr_graph, false);
         }
 
-        pub fn insertStaleExtra(
-            g: *@This(),
-            abs_path: []const u8,
-            is_ssr_graph: bool,
-            comptime is_route: bool,
-            route_index: if (is_route) Route.Index else void,
-        ) bun.OOM!FileIndex {
+        pub fn insertStaleExtra(g: *@This(), abs_path: []const u8, is_ssr_graph: bool, is_route: bool) bun.OOM!FileIndex {
             g.owner().graph_safety_lock.assertLocked();
 
             debug.log("Insert stale: {s}", .{abs_path});
@@ -2087,18 +2135,10 @@ pub fn IncrementalGraph(side: bake.Side) type {
                 }
             }
 
-            if (is_route) {
-                g.owner().routes[route_index.get()].server_file = file_index.toOptional();
-            }
-
             if (g.stale_files.bit_length > gop.index) {
                 g.stale_files.set(gop.index);
             }
 
-            if (is_route) {
-                try g.owner().route_lookup.put(g.owner().allocator, file_index, route_index);
-            }
-
             switch (side) {
                 .client => {
                     gop.value_ptr.* = File.init("", .{
@@ -2221,7 +2261,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
             };
             const failure = try SerializedFailure.initFromLog(
                 fail_owner,
-                bun.path.relative(dev.cwd, abs_path),
+                dev.relativePath(abs_path),
                 log.msgs.items,
             );
             const fail_gop = try dev.bundling_failures.getOrPut(dev.allocator, failure);
@@ -2232,7 +2272,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
             }
         }
 
-        pub fn ensureStaleBitCapacity(g: *@This(), val: bool) !void {
+        pub fn ensureStaleBitCapacity(g: *@This(), are_new_files_stale: bool) !void {
             try g.stale_files.resize(
                 g.owner().allocator,
                 std.mem.alignForward(
@@ -2241,7 +2281,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
                     // allocate 8 in 8 usize chunks
                     std.mem.byte_size_in_bits * @sizeOf(usize) * 8,
                 ),
-                val,
+                are_new_files_stale,
             );
         }
 
@@ -2283,17 +2323,26 @@ pub fn IncrementalGraph(side: bake.Side) type {
             if (side == .client) g.current_css_files.clearRetainingCapacity();
         }
 
-        pub fn takeBundle(g: *@This(), kind: ChunkKind) ![]const u8 {
+        pub fn takeBundle(
+            g: *@This(),
+            kind: ChunkKind,
+            initial_response_entry_point: []const u8,
+        ) ![]const u8 {
             var chunk = std.ArrayList(u8).init(g.owner().allocator);
-            try g.takeBundleToList(kind, &chunk);
+            try g.takeBundleToList(kind, &chunk, initial_response_entry_point);
             bun.assert(chunk.items.len == chunk.capacity);
             return chunk.items;
         }
 
-        pub fn takeBundleToList(g: *@This(), kind: ChunkKind, list: *std.ArrayList(u8)) !void {
+        pub fn takeBundleToList(
+            g: *@This(),
+            kind: ChunkKind,
+            list: *std.ArrayList(u8),
+            initial_response_entry_point: []const u8,
+        ) !void {
             g.owner().graph_safety_lock.assertLocked();
             // initial bundle needs at least the entry point
-            // hot updates shouldnt be emitted if there are no chunks
+            // hot updates shouldn't be emitted if there are no chunks
             assert(g.current_chunk_len > 0);
 
             const runtime = switch (kind) {
@@ -2314,12 +2363,8 @@ pub fn IncrementalGraph(side: bake.Side) type {
                     .initial_response => {
                         const fw = g.owner().framework;
                         try w.writeAll("}, {\n  main: ");
-                        const entry = switch (side) {
-                            .server => fw.entry_server,
-                            .client => fw.entry_client,
-                        };
                         try bun.js_printer.writeJSONString(
-                            bun.path.relative(g.owner().cwd, entry),
+                            g.owner().relativePath(initial_response_entry_point),
                             @TypeOf(w),
                             w,
                             .utf8,
@@ -2332,7 +2377,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
                                 if (fw.react_fast_refresh) |rfr| {
                                     try w.writeAll(",\n  refresh: ");
                                     try bun.js_printer.writeJSONString(
-                                        bun.path.relative(g.owner().cwd, rfr.import_source),
+                                        g.owner().relativePath(rfr.import_source),
                                         @TypeOf(w),
                                         w,
                                         .utf8,
@@ -2375,7 +2420,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
             }
             list.appendSliceAssumeCapacity(end);
 
-            if (g.owner().dump_dir) |dump_dir| {
+            if (bun.FeatureFlags.bake_debugging_features) if (g.owner().dump_dir) |dump_dir| {
                 const rel_path_escaped = "latest_chunk.js";
                 dumpBundle(dump_dir, switch (side) {
                     .client => .client,
@@ -2384,7 +2429,7 @@ pub fn IncrementalGraph(side: bake.Side) type {
                     bun.handleErrorReturnTrace(err, @errorReturnTrace());
                     Output.warn("Could not dump bundle: {}", .{err});
                 };
-            }
+            };
         }
 
         fn disconnectAndDeleteFile(g: *@This(), file_index: FileIndex) void {
@@ -2406,6 +2451,12 @@ pub fn IncrementalGraph(side: bake.Side) type {
                 }
             }
 
+            // TODO: it is infeasible to do this since FrameworkRouter contains file indices
+            // to the server graph
+            {
+                return;
+            }
+
             g.bundled_files.swapRemoveAt(file_index.get());
 
             // Move out-of-line data from `last` to replace `file_index`
@@ -2478,8 +2529,10 @@ pub fn IncrementalGraph(side: bake.Side) type {
 
 const IncrementalResult = struct {
     /// When tracing a file's dependencies via `traceDependencies`, this is
-    /// populated with the hit routes. Tracing is used for many purposes.
-    routes_affected: ArrayListUnmanaged(Route.Index),
+    /// populated with the hit `Route.Index`s. To know what `RouteBundle`s
+    /// are affected, the route graph must be traced downwards.
+    /// Tracing is used for multiple purposes.
+    routes_affected: ArrayListUnmanaged(RouteIndexAndRecurseFlag),
 
     // Following three fields are populated during `receiveChunk`
 
@@ -2508,6 +2561,7 @@ const IncrementalResult = struct {
     failures_added: ArrayListUnmanaged(SerializedFailure),
 
     /// Removing files clobbers indices, so removing anything is deferred.
+    // TODO: remove
     delete_client_files_later: ArrayListUnmanaged(IncrementalGraph(.client).FileIndex),
 
     const empty: IncrementalResult = .{
@@ -2545,6 +2599,12 @@ const GraphTraceState = struct {
     }
 };
 
+const TraceImportGoal = struct {
+    // gts: *GraphTraceState,
+    find_css: bool = false,
+    find_client_modules: bool = false,
+};
+
 fn initGraphTraceState(dev: *const DevServer, sfa: Allocator) !GraphTraceState {
     const server_bits = try DynamicBitSetUnmanaged.initEmpty(sfa, dev.server_graph.bundled_files.count());
     errdefer server_bits.deinit(sfa);
@@ -2824,7 +2884,7 @@ pub const SerializedFailure = struct {
     /// is given to the HMR runtime as an opaque handle.
     pub const Owner = union(enum) {
         none,
-        route: Route.Index,
+        route: RouteBundle.Index,
         client: IncrementalGraph(.client).FileIndex,
         server: IncrementalGraph(.server).FileIndex,
 
@@ -2846,7 +2906,7 @@ pub const SerializedFailure = struct {
                     .none => .none,
                     .client => .{ .client = IncrementalGraph(.client).FileIndex.init(owner.data) },
                     .server => .{ .server = IncrementalGraph(.server).FileIndex.init(owner.data) },
-                    .route => .{ .route = Route.Index.init(owner.data) },
+                    .route => .{ .route = RouteBundle.Index.init(owner.data) },
                 };
             }
         };
@@ -3056,11 +3116,19 @@ fn dumpBundle(dump_dir: std.fs.Dir, side: bake.Graph, rel_path: []const u8, chun
 }
 
 fn emitVisualizerMessageIfNeeded(dev: *DevServer) !void {
+    if (!bun.FeatureFlags.bake_debugging_features) return;
     if (dev.emit_visualizer_events == 0) return;
 
     var sfb = std.heap.stackFallback(65536, bun.default_allocator);
     var payload = try std.ArrayList(u8).initCapacity(sfb.get(), 65536);
     defer payload.deinit();
+
+    try dev.writeVisualizerMessage(&payload);
+
+    dev.publish(HmrSocket.visualizer_topic, payload.items, .binary);
+}
+
+fn writeVisualizerMessage(dev: *DevServer, payload: *std.ArrayList(u8)) !void {
     payload.appendAssumeCapacity(MessageId.visualizer.char());
     const w = payload.writer();
 
@@ -3074,9 +3142,10 @@ fn emitVisualizerMessageIfNeeded(dev: *DevServer) !void {
             g.bundled_files.values(),
             0..,
         ) |k, v, i| {
-            try w.writeInt(u32, @intCast(k.len), .little);
+            const normalized_key = dev.relativePath(k);
+            try w.writeInt(u32, @intCast(normalized_key.len), .little);
             if (k.len == 0) continue;
-            try w.writeAll(k);
+            try w.writeAll(normalized_key);
             try w.writeByte(@intFromBool(g.stale_files.isSet(i) or switch (side) {
                 .server => v.failed,
                 .client => v.flags.failed,
@@ -3103,8 +3172,6 @@ fn emitVisualizerMessageIfNeeded(dev: *DevServer) !void {
             try w.writeInt(u32, @intCast(edge.imported.get()), .little);
         }
     }
-
-    _ = dev.app.publish(HmrSocket.visualizer_topic, payload.items, .binary, false);
 }
 
 pub fn onWebSocketUpgrade(
@@ -3198,7 +3265,7 @@ pub const MessageId = enum(u8) {
     ///   - `u32`: File index of the imported file
     visualizer = 'v',
 
-    pub fn char(id: MessageId) u8 {
+    pub inline fn char(id: MessageId) u8 {
         return @intFromEnum(id);
     }
 };
@@ -3217,12 +3284,12 @@ const HmrSocket = struct {
     pub const global_topic = "*";
     pub const visualizer_topic = "v";
 
-    pub fn onOpen(dw: *HmrSocket, ws: AnyWebSocket) void {
-        _ = ws.send(&(.{MessageId.version.char()} ++ dw.dev.configuration_hash_key), .binary, false, true);
+    pub fn onOpen(s: *HmrSocket, ws: AnyWebSocket) void {
+        _ = ws.send(&(.{MessageId.version.char()} ++ s.dev.configuration_hash_key), .binary, false, true);
         _ = ws.subscribe(global_topic);
     }
 
-    pub fn onMessage(dw: *HmrSocket, ws: AnyWebSocket, msg: []const u8, opcode: uws.Opcode) void {
+    pub fn onMessage(s: *HmrSocket, ws: AnyWebSocket, msg: []const u8, opcode: uws.Opcode) void {
         _ = opcode;
 
         if (msg.len == 0) {
@@ -3232,11 +3299,11 @@ const HmrSocket = struct {
 
         switch (@as(IncomingMessageId, @enumFromInt(msg[0]))) {
             .visualizer => {
-                if (!dw.emit_visualizer_events) {
-                    dw.emit_visualizer_events = true;
-                    dw.dev.emit_visualizer_events += 1;
+                if (!s.emit_visualizer_events) {
+                    s.emit_visualizer_events = true;
+                    s.dev.emit_visualizer_events += 1;
                     _ = ws.subscribe(visualizer_topic);
-                    dw.dev.emitVisualizerMessageIfNeeded() catch bun.outOfMemory();
+                    s.dev.emitVisualizerMessageIfNeeded() catch bun.outOfMemory();
                 }
             },
             else => {
@@ -3245,73 +3312,36 @@ const HmrSocket = struct {
         }
     }
 
-    pub fn onClose(dw: *HmrSocket, ws: AnyWebSocket, exit_code: i32, message: []const u8) void {
+    pub fn onClose(s: *HmrSocket, ws: AnyWebSocket, exit_code: i32, message: []const u8) void {
         _ = ws;
         _ = exit_code;
         _ = message;
 
-        if (dw.emit_visualizer_events) {
-            dw.dev.emit_visualizer_events -= 1;
+        if (s.emit_visualizer_events) {
+            s.dev.emit_visualizer_events -= 1;
         }
 
-        defer dw.dev.allocator.destroy(dw);
-    }
-};
-
-/// Bake uses a special global object extending Zig::GlobalObject
-pub const DevGlobalObject = opaque {
-    /// Safe downcast to use other Bun APIs
-    pub fn js(ptr: *DevGlobalObject) *JSC.JSGlobalObject {
-        return @ptrCast(ptr);
-    }
-
-    pub fn vm(ptr: *DevGlobalObject) *JSC.VM {
-        return ptr.js().vm();
+        defer s.dev.allocator.destroy(s);
     }
 };
 
-pub const BakeSourceProvider = opaque {};
-
 const c = struct {
-    // BakeDevGlobalObject.cpp
-    extern fn BakeCreateDevGlobal(owner: *DevServer, console: *JSC.ConsoleObject) *DevGlobalObject;
-
     // BakeSourceProvider.cpp
     extern fn BakeGetDefaultExportFromModule(global: *JSC.JSGlobalObject, module: JSValue) JSValue;
 
-    const LoadServerCodeResult = struct {
-        promise: *JSInternalPromise,
-        key: *JSC.JSString,
-    };
-
-    fn BakeLoadServerHmrPatch(global: *DevGlobalObject, code: bun.String) !JSValue {
-        const f = @extern(*const fn (*DevGlobalObject, bun.String) callconv(.C) JSValue, .{
-            .name = "BakeLoadServerHmrPatch",
-        });
-        const result = f(global, code);
-        if (result == .zero) {
-            if (Environment.allow_assert) assert(global.js().hasException());
-            return error.JSError;
-        }
-        return result;
+    fn BakeLoadServerHmrPatch(global: *JSC.JSGlobalObject, code: bun.String) !JSValue {
+        const f = @extern(
+            *const fn (*JSC.JSGlobalObject, bun.String) callconv(.C) JSValue.MaybeException,
+            .{ .name = "BakeLoadServerHmrPatch" },
+        );
+        return f(global, code).unwrap();
     }
 
-    fn BakeLoadInitialServerCode(global: *DevGlobalObject, code: bun.String) bun.JSError!LoadServerCodeResult {
-        const Return = extern struct {
-            promise: ?*JSInternalPromise,
-            key: *JSC.JSString,
-        };
-        const f = @extern(*const fn (*DevGlobalObject, bun.String) callconv(.C) Return, .{
+    fn BakeLoadInitialServerCode(global: *JSC.JSGlobalObject, code: bun.String, separate_ssr_graph: bool) bun.JSError!JSValue {
+        const f = @extern(*const fn (*JSC.JSGlobalObject, bun.String, bool) callconv(.C) JSValue.MaybeException, .{
             .name = "BakeLoadInitialServerCode",
         });
-        const result = f(global, code);
-        return .{
-            .promise = result.promise orelse {
-                if (Environment.allow_assert) assert(global.js().hasException());
-                return error.JSError;
-            },
-            .key = result.key,
-        };
+        return f(global, code, separate_ssr_graph).unwrap();
     }
 };
 
@@ -3331,7 +3361,7 @@ pub fn reload(dev: *DevServer, reload_task: *HotReloadTask) bun.OOM!void {
         @panic("timers unsupported");
 
     var sfb = std.heap.stackFallback(4096, bun.default_allocator);
-    const temp_alloc = sfb.get();
+    var temp_alloc = sfb.get();
 
     // pre-allocate a few files worth of strings. it is unlikely but supported
     // to change more than 8 files in the same bundling round.
@@ -3352,15 +3382,6 @@ pub fn reload(dev: *DevServer, reload_task: *HotReloadTask) bun.OOM!void {
         return;
     }
 
-    const reload_file_list = bun.Output.Scoped(.reload_file_list, false);
-
-    if (reload_file_list.isVisible()) {
-        reload_file_list.log("Hot update hits {d} files", .{files.items.len});
-        for (files.items) |f| {
-            reload_file_list.log("- {s} (.{s})", .{ f.path, @tagName(f.graph) });
-        }
-    }
-
     dev.incremental_result.reset();
     defer {
         // Remove files last to start, to avoid issues where removing a file
@@ -3387,23 +3408,48 @@ pub fn reload(dev: *DevServer, reload_task: *HotReloadTask) bun.OOM!void {
 
     // This list of routes affected excludes client code. This means changing
     // a client component wont count as a route to trigger a reload on.
+    //
+    // A second trace is required to determine what routes had changed bundles,
+    // since changing a layout affects all child routes. Additionally, routes
+    // that do not have a bundle will not be cleared (as there is nothing to
+    // clear for those)
     if (dev.incremental_result.routes_affected.items.len > 0) {
+        // re-use some earlier stack memory
+        files.clearAndFree();
+        sfb = std.heap.stackFallback(4096, bun.default_allocator);
+        temp_alloc = sfb.get();
+
+        // A bit-set is used to avoid duplicate entries. This is not a problem
+        // with `dev.incremental_result.routes_affected`
+        var second_trace_result = try DynamicBitSetUnmanaged.initEmpty(temp_alloc, dev.route_bundles.items.len);
+        for (dev.incremental_result.routes_affected.items) |request| {
+            const route = dev.router.routePtr(request.route_index);
+            if (route.bundle.unwrap()) |id| second_trace_result.set(id.get());
+            if (request.should_recurse_when_visiting) {
+                markAllRouteChildren(&dev.router, &second_trace_result, request.route_index);
+            }
+        }
+
         var sfb2 = std.heap.stackFallback(65536, bun.default_allocator);
         var payload = std.ArrayList(u8).initCapacity(sfb2.get(), 65536) catch
             unreachable; // enough space
         defer payload.deinit();
         payload.appendAssumeCapacity(MessageId.route_update.char());
         const w = payload.writer();
-        try w.writeInt(u32, @intCast(dev.incremental_result.routes_affected.items.len), .little);
-
-        for (dev.incremental_result.routes_affected.items) |route| {
-            try w.writeInt(u32, route.get(), .little);
-            const pattern = dev.routes[route.get()].pattern;
+        const count = second_trace_result.count();
+        assert(count > 0);
+        try w.writeInt(u32, @intCast(count), .little);
+
+        var it = second_trace_result.iterator(.{ .kind = .set });
+        while (it.next()) |bundled_route_index| {
+            try w.writeInt(u32, @intCast(bundled_route_index), .little);
+            const pattern = dev.route_bundles.items[bundled_route_index].full_pattern;
             try w.writeInt(u32, @intCast(pattern.len), .little);
             try w.writeAll(pattern);
         }
 
-        _ = dev.app.publish(HmrSocket.global_topic, payload.items, .binary, true);
+        // Notify
+        dev.publish(HmrSocket.global_topic, payload.items, .binary);
     }
 
     // When client component roots get updated, the `client_components_affected`
@@ -3423,13 +3469,14 @@ pub fn reload(dev: *DevServer, reload_task: *HotReloadTask) bun.OOM!void {
             try dev.server_graph.traceDependencies(index, .no_stop);
         }
 
-        for (dev.incremental_result.routes_affected.items) |route| {
-            // Free old bundles
-            if (dev.routes[route.get()].client_bundle) |old| {
-                dev.allocator.free(old);
-            }
-            dev.routes[route.get()].client_bundle = null;
-        }
+        // TODO:
+        // for (dev.incremental_result.routes_affected.items) |route| {
+        //     // Free old bundles
+        //     if (dev.routes[route.get()].client_bundle) |old| {
+        //         dev.allocator.free(old);
+        //     }
+        //     dev.routes[route.get()].client_bundle = null;
+        // }
     }
 
     // TODO: improve this visual feedback
@@ -3446,7 +3493,7 @@ pub fn reload(dev: *DevServer, reload_task: *HotReloadTask) bun.OOM!void {
             Output.prettyError("<cyan>[x{d}]<r> ", .{dev.bundles_since_last_error});
         }
 
-        Output.prettyError("<green>Reloaded in {d}ms<r><d>:<r> {s}", .{ @divFloor(timer.read(), std.time.ns_per_ms), bun.path.relative(dev.cwd, changed_file_paths[0]) });
+        Output.prettyError("<green>Reloaded in {d}ms<r><d>:<r> {s}", .{ @divFloor(timer.read(), std.time.ns_per_ms), dev.relativePath(changed_file_paths[0]) });
         if (changed_file_paths.len > 1) {
             Output.prettyError(" <d>+ {d} more<r>", .{files.items.len - 1});
         }
@@ -3455,6 +3502,16 @@ pub fn reload(dev: *DevServer, reload_task: *HotReloadTask) bun.OOM!void {
     } else {}
 }
 
+fn markAllRouteChildren(router: *FrameworkRouter, bits: *DynamicBitSetUnmanaged, route_index: Route.Index) void {
+    var next = router.routePtr(route_index).first_child.unwrap();
+    while (next) |child_index| {
+        const route = router.routePtr(child_index);
+        if (route.bundle.unwrap()) |index| bits.set(index.get());
+        markAllRouteChildren(router, bits, child_index);
+        next = route.next_sibling.unwrap();
+    }
+}
+
 pub const HotReloadTask = struct {
     /// Align to cache lines to reduce contention.
     const Aligned = struct { aligned: HotReloadTask align(std.atomic.cache_line) };
@@ -3585,7 +3642,8 @@ pub fn onFileUpdate(dev: *DevServer, events: []Watcher.Event, changed_files: []?
             },
             .directory => {
                 // bust the directory cache since this directory has changed
-                _ = dev.server_bundler.resolver.bustDirCache(file_path);
+                // TODO: correctly solve https://github.com/oven-sh/bun/issues/14913
+                _ = dev.server_bundler.resolver.bustDirCache(bun.strings.withoutTrailingSlash(file_path));
 
                 // if a directory watch exists for resolution
                 // failures, check those now.
@@ -3636,6 +3694,107 @@ pub fn onWatchError(_: *DevServer, err: bun.sys.Error) void {
     }
 }
 
+pub fn publish(dev: *DevServer, topic: []const u8, message: []const u8, opcode: uws.Opcode) void {
+    if (dev.server) |s| _ = s.publish(topic, message, opcode, false);
+}
+
+pub fn numSubscribers(dev: *DevServer, topic: []const u8) u32 {
+    return if (dev.server) |s| s.numSubscribers(topic) else 0;
+}
+
+const SafeFileId = packed struct(u32) {
+    side: bake.Side,
+    index: u30,
+    unused: enum(u1) { unused = 0 } = .unused,
+};
+
+/// Interface function for FrameworkRouter
+pub fn getFileIdForRouter(dev: *DevServer, abs_path: []const u8, associated_route: Route.Index, file_kind: Route.FileKind) !OpaqueFileId {
+    const index = try dev.server_graph.insertStaleExtra(abs_path, false, true);
+    try dev.route_lookup.put(dev.allocator, index, .{
+        .route_index = associated_route,
+        .should_recurse_when_visiting = file_kind == .layout,
+    });
+    return toOpaqueFileId(.server, index);
+}
+
+fn toOpaqueFileId(comptime side: bake.Side, index: IncrementalGraph(side).FileIndex) OpaqueFileId {
+    if (Environment.allow_assert) {
+        return OpaqueFileId.init(@bitCast(SafeFileId{
+            .side = side,
+            .index = index.get(),
+        }));
+    }
+
+    return OpaqueFileId.init(index.get());
+}
+
+fn fromOpaqueFileId(comptime side: bake.Side, id: OpaqueFileId) IncrementalGraph(side).FileIndex {
+    if (Environment.allow_assert) {
+        const safe: SafeFileId = @bitCast(id.get());
+        assert(side == safe.side);
+        return IncrementalGraph(side).FileIndex.init(safe.index);
+    }
+    return IncrementalGraph(side).FileIndex.init(@intCast(id.get()));
+}
+
+fn relativePath(dev: *const DevServer, path: []const u8) []const u8 {
+    // TODO: windows slash normalization
+    bun.assert(dev.root[dev.root.len - 1] != '/');
+    if (path.len >= dev.root.len + 1 and
+        path[dev.root.len] == '/' and
+        bun.strings.startsWith(path, dev.root))
+    {
+        return path[dev.root.len + 1 ..];
+    }
+    return bun.path.relative(dev.root, path);
+}
+
+fn dumpStateDueToCrash(dev: *DevServer) !void {
+    comptime assert(bun.FeatureFlags.bake_debugging_features);
+
+    // being conservative about how much stuff is put on the stack.
+    var filepath_buf: [@min(4096, bun.MAX_PATH_BYTES)]u8 = undefined;
+    const filepath = std.fmt.bufPrintZ(&filepath_buf, "incremental-graph-crash-dump.{d}.html", .{std.time.timestamp()}) catch "incremental-graph-crash-dump.html";
+    const file = std.fs.cwd().createFileZ(filepath, .{}) catch |err| {
+        bun.handleErrorReturnTrace(err, @errorReturnTrace());
+        Output.warn("Could not open directory for dumping sources: {}", .{err});
+        return;
+    };
+    defer file.close();
+
+    const start, const end = comptime brk: {
+        const visualizer = @embedFile("incremental_visualizer.html");
+        const i = (std.mem.indexOf(u8, visualizer, "<script>") orelse unreachable) + "<script>".len;
+        break :brk .{ visualizer[0..i], visualizer[i..] };
+    };
+    try file.writeAll(start);
+    try file.writeAll("\nlet inlinedData = Uint8Array.from(atob(\"");
+
+    var sfb = std.heap.stackFallback(4096, bun.default_allocator);
+    var payload = try std.ArrayList(u8).initCapacity(sfb.get(), 4096);
+    defer payload.deinit();
+    try dev.writeVisualizerMessage(&payload);
+
+    var buf: [bun.base64.encodeLenFromSize(4096)]u8 = undefined;
+    var it = std.mem.window(u8, payload.items, 4096, 4096);
+    while (it.next()) |chunk| {
+        try file.writeAll(buf[0..bun.base64.encode(&buf, chunk)]);
+    }
+
+    try file.writeAll("\"), c => c.charCodeAt(0));\n");
+    try file.writeAll(end);
+
+    Output.note("Dumped incremental bundler graph to {}", .{bun.fmt.quote(filepath)});
+}
+
+// const RouteIndexAndRecurseFlag = packed struct(u32) {
+const RouteIndexAndRecurseFlag = struct {
+    route_index: Route.Index,
+    /// Set true for layout
+    should_recurse_when_visiting: bool,
+};
+
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const Mutex = std.Thread.Mutex;
@@ -3648,6 +3807,9 @@ const assert = bun.assert;
 const DynamicBitSetUnmanaged = bun.bit_set.DynamicBitSetUnmanaged;
 
 const bake = bun.bake;
+const FrameworkRouter = bake.FrameworkRouter;
+const Route = FrameworkRouter.Route;
+const OpaqueFileId = FrameworkRouter.OpaqueFileId;
 
 const Log = bun.logger.Log;
 const Output = bun.Output;
diff --git a/src/bake/FrameworkRouter.zig b/src/bake/FrameworkRouter.zig
index 49cc33d7a59daf..f863c8b0b047b8 100644
--- a/src/bake/FrameworkRouter.zig
+++ b/src/bake/FrameworkRouter.zig
@@ -1,3 +1,1187 @@
 //! Discovers routes from the filesystem, as instructed by the framework
-//! configuration. Supports incrementally updating for DevServer, or
-//! serializing to a binary for production builds.
+//! configuration. Agnotic to all different paradigms. Supports incrementally
+//! updating for DevServer, or serializing to a binary for use in production.
+const FrameworkRouter = @This();
+
+/// Metadata for route files is specified out of line, either in DevServer where
+/// it is an IncrementalGraph(.server).FileIndex or the production build context
+/// where it is an entrypoint index.
+pub const OpaqueFileId = bun.GenericIndex(u32, opaque {});
+
+types: []Type,
+routes: std.ArrayListUnmanaged(Route),
+/// Keys are full URL, with leading /, no trailing /
+/// Value is Route Index
+static_routes: StaticRouteMap,
+/// A flat list of all dynamic patterns.
+///
+/// Used to detect routes that have the same effective URL. Examples:
+/// - `/hello/[foo]/bar` and `/hello/[baz]`bar`
+/// - `/(one)/abc/def` and `/(two)/abc/def`
+///
+/// Note that file that match to the same exact route are already caught as
+/// errors since the Route cannot store a list of files. Examples:
+/// - `/about/index.tsx` and `/about.tsx` with style `.nextjs-pages`
+/// Key in this map is EncodedPattern.
+///
+/// Root files are not caught using this technique, since every route tree has a
+/// root. This check is special cased.
+// TODO: no code to sort this data structure
+dynamic_routes: DynamicRouteMap,
+
+/// The above structure is optimized for incremental updates, but
+/// production has a different set of requirements:
+/// - Trivially serializable to a binary file (no pointers)
+/// - As little memory indirection as possible.
+/// - Routes cannot be updated after serilaization.
+pub const Serialized = struct {
+    // TODO:
+};
+
+const StaticRouteMap = bun.StringArrayHashMapUnmanaged(Route.Index);
+const DynamicRouteMap = std.ArrayHashMapUnmanaged(EncodedPattern, Route.Index, EncodedPattern.EffectiveURLContext, true);
+
+/// A logical route, for which layouts are looked up on after resolving a route.
+pub const Route = struct {
+    part: Part,
+    type: Type.Index,
+
+    parent: Index.Optional,
+    first_child: Route.Index.Optional,
+    prev_sibling: Route.Index.Optional,
+    next_sibling: Route.Index.Optional,
+
+    // Note: A route may be associated with no files, in which it is just a
+    // construct for building the tree.
+    file_page: OpaqueFileId.Optional = .none,
+    file_layout: OpaqueFileId.Optional = .none,
+    // file_not_found: OpaqueFileId.Optional = .none,
+
+    /// Only used by DevServer, if this route is 1. navigatable & 2. has been requested at least once
+    bundle: bun.bake.DevServer.RouteBundle.Index.Optional = .none,
+
+    inline fn filePtr(r: *Route, file_kind: FileKind) *OpaqueFileId.Optional {
+        return &switch (file_kind) {
+            inline else => |kind| @field(r, "file_" ++ @tagName(kind)),
+        };
+    }
+
+    pub const FileKind = enum {
+        page,
+        layout,
+        // not_found,
+    };
+
+    pub const Index = bun.GenericIndex(u31, Route);
+};
+
+/// Native code for `FrameworkFileSystemRouterType`
+pub const Type = struct {
+    abs_root: []const u8,
+    prefix: []const u8 = "/",
+    ignore_underscores: bool = false,
+    ignore_dirs: []const []const u8 = &.{ ".git", "node_modules" },
+    extensions: []const []const u8,
+    style: Style,
+    /// `FrameworkRouter` itself does not use this value.
+    client_file: OpaqueFileId.Optional,
+    /// `FrameworkRouter` itself does not use this value.
+    server_file: OpaqueFileId,
+    /// `FrameworkRouter` itself does not use this value.
+    server_file_string: JSC.Strong,
+
+    pub fn rootRouteIndex(type_index: Index) Route.Index {
+        return Route.Index.init(type_index.get());
+    }
+
+    pub const Index = bun.GenericIndex(u8, Type);
+};
+
+pub fn initEmpty(types: []Type, allocator: Allocator) !FrameworkRouter {
+    var routes = try std.ArrayListUnmanaged(Route).initCapacity(allocator, types.len);
+    errdefer routes.deinit(allocator);
+
+    for (0..types.len) |type_index| {
+        routes.appendAssumeCapacity(.{
+            .part = .{ .text = "" },
+            .type = Type.Index.init(@intCast(type_index)),
+            .parent = .none,
+            .prev_sibling = .none,
+            .next_sibling = .none,
+            .first_child = .none,
+            .file_page = .none,
+            .file_layout = .none,
+            // .file_not_found = .none,
+        });
+    }
+    return .{
+        .types = types,
+        .routes = routes,
+        .dynamic_routes = .{},
+        .static_routes = .{},
+    };
+}
+
+pub fn deinit(fr: *FrameworkRouter, allocator: Allocator) void {
+    fr.routes.deinit(allocator);
+    allocator.free(fr.types);
+}
+
+pub fn scanAll(fr: *FrameworkRouter, allocator: Allocator, r: *Resolver, ctx: anytype) !void {
+    for (fr.types, 0..) |ty, i| {
+        _ = ty;
+        try fr.scan(allocator, FrameworkRouter.Type.Index.init(@intCast(i)), r, ctx);
+    }
+}
+
+/// Route patterns are serialized in a stable byte format so it can be treated
+/// as a string, while easily decodable as []Part.
+pub const EncodedPattern = struct {
+    data: []const u8,
+
+    /// `/` is represented by zero bytes
+    pub const root: EncodedPattern = .{ .data = &.{} };
+
+    pub fn patternSerializedLength(parts: []const Part) usize {
+        var size: usize = 0;
+        for (parts) |part| {
+            size += @sizeOf(u32) + switch (part) {
+                inline else => |t| t.len,
+            };
+        }
+        return size;
+    }
+
+    pub fn initFromParts(parts: []const Part, allocator: Allocator) !EncodedPattern {
+        const slice = try allocator.alloc(u8, patternSerializedLength(parts));
+        var s = std.io.fixedBufferStream(slice);
+        for (parts) |part|
+            part.writeAsSerialized(s.writer()) catch
+                unreachable; // enough space
+        bun.assert(s.pos == s.buffer.len);
+        return .{ .data = slice };
+    }
+
+    pub fn iterate(p: EncodedPattern) Iterator {
+        return .{ .pattern = p, .offset = 0 };
+    }
+
+    pub fn partAt(pattern: EncodedPattern, byte_offset: usize) ?Part {
+        return (Iterator{
+            .pattern = pattern,
+            .offset = byte_offset,
+        }).peek();
+    }
+
+    const Iterator = struct {
+        pattern: EncodedPattern,
+        offset: usize,
+
+        pub fn readWithSize(it: Iterator) struct { Part, usize } {
+            const header: Part.SerializedHeader = @bitCast(mem.readInt(
+                u32,
+                it.pattern.data[it.offset..][0..@sizeOf(u32)],
+                .little,
+            ));
+            return .{
+                switch (header.tag) {
+                    inline else => |tag| @unionInit(
+                        Part,
+                        @tagName(tag),
+                        it.pattern.data[it.offset + @sizeOf(u32) ..][0..header.len],
+                    ),
+                },
+                @sizeOf(u32) + header.len,
+            };
+        }
+
+        pub fn peek(it: Iterator) Part {
+            return it.readWithSize().@"0";
+        }
+
+        pub fn next(it: *Iterator) ?Part {
+            if (it.offset >= it.pattern.data.len)
+                return null;
+            const part, const len = it.readWithSize();
+            it.offset += len;
+            return part;
+        }
+    };
+
+    pub fn effectiveURLHash(k: EncodedPattern) usize {
+        // The strategy is to write all bytes, then hash them. Avoiding
+        // multiple hash calls on small chunks. Allocation is not needed
+        // since the upper bound is known (file path limits)
+        var stack_space: [std.fs.max_path_bytes * 2]u8 = undefined;
+        var stream = std.io.fixedBufferStream(&stack_space);
+        const w = stream.writer();
+        var it = k.iterate();
+        while (it.next()) |item| switch (item) {
+            .text => |text| {
+                w.writeAll("/") catch unreachable;
+                w.writeAll(text) catch unreachable;
+            },
+            // param names are not visible
+            .param => w.writeAll(":") catch unreachable,
+            .catch_all => w.writeAll(":.") catch unreachable,
+            .catch_all_optional => w.writeAll(":?") catch unreachable,
+            // groups are completely unobservable
+            .group => continue,
+        };
+        return bun.hash(stream.getWritten());
+    }
+
+    fn matches(p: EncodedPattern, path: []const u8, params: *MatchedParams) bool {
+        var param_num: usize = 0;
+        var it = p.iterate();
+        var i: usize = 1;
+        while (it.next()) |part| {
+            switch (part) {
+                .text => |expect| {
+                    if (path.len < i + expect.len or
+                        !(path.len == i + expect.len or path[i + expect.len] == '/'))
+                        return false;
+                    if (!strings.eql(path[i..][0..expect.len], expect))
+                        return false;
+                    i += 1 + expect.len;
+                },
+                .param => |name| {
+                    const end = strings.indexOfCharPos(path, '/', i) orelse path.len;
+                    params.params.len = @intCast(param_num + 1);
+                    params.params.buffer[param_num] = .{
+                        .key = name,
+                        .value = path[i..end],
+                    };
+                    param_num += 1;
+                    i = if (end == path.len) end else end + 1;
+                },
+                .catch_all_optional => return true,
+                .catch_all => break,
+                .group => continue,
+            }
+        }
+        return i == path.len;
+    }
+
+    pub const EffectiveURLContext = struct {
+        pub fn hash(_: @This(), p: EncodedPattern) u32 {
+            return @truncate(p.effectiveURLHash());
+        }
+
+        pub fn eql(_: @This(), a: EncodedPattern, b: EncodedPattern, _: usize) bool {
+            return a.effectiveURLHash() == b.effectiveURLHash();
+        }
+    };
+};
+
+/// Wrapper around a slice to provide same interface to be used in `insert`
+/// but with the allocation being backed by a plain string, which each
+/// part separated by slashes.
+const StaticPattern = struct {
+    route_path: []const u8,
+
+    pub fn iterate(p: StaticPattern) Iterator {
+        return .{ .pattern = p, .offset = 0 };
+    }
+
+    const Iterator = struct {
+        pattern: StaticPattern,
+        offset: usize,
+
+        pub fn readWithSize(it: Iterator) struct { Part, usize } {
+            const next_i = bun.strings.indexOfCharPos(it.pattern.route_path, '/', it.offset + 1) orelse
+                it.pattern.route_path.len;
+            const text = it.pattern.route_path[it.offset + 1 .. next_i];
+            return .{ .{ .text = text }, text.len + 1 };
+        }
+
+        pub fn peek(it: Iterator) Part {
+            return it.readWithSize().@"0";
+        }
+
+        pub fn next(it: *Iterator) ?Part {
+            if (it.offset >= it.pattern.route_path.len)
+                return null;
+            const part, const len = it.readWithSize();
+            it.offset += len;
+            return part;
+        }
+    };
+};
+
+/// A part of a URL pattern
+pub const Part = union(enum(u3)) {
+    /// Does not contain slashes. One per slash.
+    text: []const u8,
+    param: []const u8,
+    /// Must be the last part of the pattern
+    catch_all_optional: []const u8,
+    /// Must be the last part of the pattern
+    catch_all: []const u8,
+    /// Does not affect URL matching, but does affect hierarchy.
+    group: []const u8,
+
+    const SerializedHeader = packed struct(u32) {
+        tag: @typeInfo(Part).Union.tag_type.?,
+        len: u29,
+    };
+
+    pub fn writeAsSerialized(part: Part, writer: anytype) !void {
+        switch (part) {
+            .text => |text| {
+                bun.assert(text.len > 0);
+                bun.assert(bun.strings.indexOfChar(text, '/') == null);
+            },
+            else => {},
+        }
+        const payload = switch (part) {
+            inline else => |t| t,
+        };
+        try writer.writeInt(u32, @bitCast(SerializedHeader{
+            .tag = std.meta.activeTag(part),
+            .len = @intCast(payload.len),
+        }), .little);
+        try writer.writeAll(payload);
+    }
+
+    pub fn eql(a: Part, b: Part) bool {
+        if (std.meta.activeTag(a) != std.meta.activeTag(b))
+            return false;
+        return switch (a) {
+            inline else => |payload, tag| bun.strings.eql(
+                payload,
+                @field(b, @tagName(tag)),
+            ),
+        };
+    }
+
+    pub fn format(part: Part, comptime fmt: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        comptime bun.assert(fmt.len == 0);
+        try writer.writeAll("Part \"");
+        try part.toStringForInternalUse(writer);
+        try writer.writeAll("\"");
+    }
+
+    fn toStringForInternalUse(part: Part, writer: anytype) !void {
+        switch (part) {
+            .text => |text| try writer.print("/{s}", .{text}),
+            .param => |param_name| try writer.print("/:{s}", .{param_name}),
+            .group => |label| try writer.print("/({s})", .{label}),
+            .catch_all => |param_name| try writer.print("/:*{s}", .{param_name}),
+            .catch_all_optional => |param_name| try writer.print("/:*?{s}", .{param_name}),
+        }
+    }
+};
+
+pub const ParsedPattern = struct {
+    parts: []const Part,
+    kind: Kind,
+
+    pub const Kind = enum {
+        /// Can be navigated to. Pages can have children, which allows having
+        /// nested routes exactly how Remix allows them.
+        page,
+        /// Is not considered when resolving navigations, but is still a valid
+        /// node in the route tree.
+        layout,
+        /// Another file related to a route
+        extra,
+    };
+};
+
+pub const Style = enum {
+    @"nextjs-pages-ui",
+    @"nextjs-pages-routes",
+    @"nextjs-app-ui",
+    @"nextjs-app-routes",
+    javascript_defined,
+
+    pub const UiOrRoutes = enum { ui, routes };
+    const NextRoutingConvention = enum { app, pages };
+
+    pub fn parse(style: Style, file_path: []const u8, ext: []const u8, log: *TinyLog, arena: Allocator) !?ParsedPattern {
+        bun.assert(file_path[0] == '/');
+
+        return switch (style) {
+            .@"nextjs-pages-ui" => parseNextJsPages(file_path, ext, log, arena, .ui),
+            .@"nextjs-pages-routes" => parseNextJsPages(file_path, ext, log, arena, .routes),
+            .@"nextjs-app-ui" => parseNextJsApp(file_path, ext, log, arena, .ui),
+            .@"nextjs-app-routes" => parseNextJsApp(file_path, ext, log, arena, .routes),
+            .javascript_defined => @panic("TODO: customizable Style"),
+        };
+    }
+
+    /// Implements the pages router parser from Next.js:
+    /// https://nextjs.org/docs/getting-started/project-structure#pages-routing-conventions
+    pub fn parseNextJsPages(file_path_raw: []const u8, ext: []const u8, log: *TinyLog, arena: Allocator, extract: UiOrRoutes) !?ParsedPattern {
+        var file_path = file_path_raw[0 .. file_path_raw.len - ext.len];
+        var kind: ParsedPattern.Kind = .page;
+        if (strings.hasSuffixComptime(file_path, "/index")) {
+            file_path.len -= "/index".len;
+        } else if (extract == .ui and strings.hasSuffixComptime(file_path, "/_layout")) {
+            file_path.len -= "/_layout".len;
+            kind = .layout;
+        }
+        if (file_path.len == 0) return .{
+            .kind = kind,
+            .parts = &.{},
+        };
+        const parts = try parseNextJsLikeRouteSegment(file_path_raw, file_path, log, arena, .pages);
+        return .{
+            .kind = kind,
+            .parts = parts,
+        };
+    }
+
+    /// Implements the app router parser from Next.js:
+    /// https://nextjs.org/docs/getting-started/project-structure#app-routing-conventions
+    pub fn parseNextJsApp(
+        file_path_raw: []const u8,
+        ext: []const u8,
+        log: *TinyLog,
+        arena: Allocator,
+        comptime extract: UiOrRoutes,
+    ) !?ParsedPattern {
+        const without_ext = file_path_raw[0 .. file_path_raw.len - ext.len];
+        const basename = std.fs.path.basename(without_ext);
+        const loader = bun.options.Loader.fromString(ext) orelse
+            return null;
+
+        // TODO: opengraph-image and metadata friends
+        if (!loader.isJavaScriptLike())
+            return null;
+
+        const kind = bun.ComptimeStringMap(ParsedPattern.Kind, switch (extract) {
+            .ui => .{
+                .{ "page", .page },
+                .{ "layout", .layout },
+
+                .{ "default", .extra },
+                .{ "template", .extra },
+                .{ "error", .extra },
+                .{ "loading", .extra },
+                .{ "not-found", .extra },
+            },
+            .routes => .{
+                .{ "route", .page },
+            },
+        }).get(basename) orelse
+            return null;
+
+        const dirname = bun.path.dirname(without_ext, .posix);
+        if (dirname.len <= 1) return .{
+            .kind = kind,
+            .parts = &.{},
+        };
+        const parts = try parseNextJsLikeRouteSegment(file_path_raw, dirname, log, arena, .app);
+        return .{
+            .kind = kind,
+            .parts = parts,
+        };
+    }
+
+    fn parseNextJsLikeRouteSegment(
+        raw_input: []const u8,
+        route_segment: []const u8,
+        log: *TinyLog,
+        arena: Allocator,
+        comptime conventions: NextRoutingConvention,
+    ) ![]Part {
+        var i: usize = 1;
+        var parts: std.ArrayListUnmanaged(Part) = .{};
+        const stop_chars = switch (conventions) {
+            .pages => "[",
+            .app => "[(@",
+        };
+        while (strings.indexOfAnyPosComptime(route_segment, stop_chars, i)) |start| {
+            if (conventions == .pages or route_segment[start] == '[') {
+                var end = strings.indexOfCharPos(route_segment, ']', start + 1) orelse
+                    return log.fail("Missing \"]\" to match this route parameter", .{}, start, raw_input.len - start);
+
+                const is_optional = route_segment[start + 1] == '[';
+
+                const param_content = route_segment[start + 1 + @as(u64, @intFromBool(is_optional)) .. end];
+
+                var has_ending_double_bracket = false;
+                if (end + 1 < route_segment.len and route_segment[end + 1] == ']') {
+                    end += 1;
+                    has_ending_double_bracket = true;
+                }
+                const len = end - start + 1;
+
+                const is_catch_all = strings.hasPrefixComptime(param_content, "...");
+                const param_name = if (is_catch_all) param_content[3..] else param_content;
+
+                if (param_name.len == 0)
+                    return log.fail("Parameter needs a name", .{}, start, len);
+                if (param_name[0] == '.')
+                    return log.fail("Parameter name cannot start with \".\" (use \"...\" for catch-all)", .{}, start, len);
+                if (is_optional and !is_catch_all)
+                    return log.fail("Optional parameters can only be catch-all (change to \"[[...{s}]]\" or remove extra brackets)", .{param_name}, start, len);
+                // Potential future proofing
+                if (std.mem.indexOfAny(u8, param_name, "?*{}()=:#,")) |bad_char_index|
+                    return log.fail("Parameter name cannot contain \"{c}\"", .{param_name[bad_char_index]}, start + bad_char_index, 1);
+
+                if (has_ending_double_bracket and !is_optional)
+                    return log.fail("Extra \"]\" in route parameter", .{}, end, 1)
+                else if (!has_ending_double_bracket and is_optional)
+                    return log.fail("Missing second \"]\" to close optional route parameter", .{}, end, 1);
+
+                if (route_segment[start - 1] != '/' or (end + 1 < route_segment.len and route_segment[end + 1] != '/'))
+                    return log.fail("Parameters must take up the entire file name", .{}, start, len);
+
+                if (is_catch_all and route_segment.len != end + 1)
+                    return log.fail("Catch-all parameter must be at the end of a route", .{}, start, len);
+
+                const between = route_segment[i..start];
+                var it = std.mem.tokenizeScalar(u8, between, '/');
+                while (it.next()) |part|
+                    try parts.append(arena, .{ .text = part });
+                try parts.append(
+                    arena,
+                    if (is_optional)
+                        .{ .catch_all_optional = param_name }
+                    else if (is_catch_all)
+                        .{ .catch_all = param_name }
+                    else
+                        .{ .param = param_name },
+                );
+
+                i = end + 1;
+            } else if (route_segment[start] == '(') {
+                const end = strings.indexOfCharPos(route_segment, ')', start + 1) orelse
+                    return log.fail("Missing \")\" to match this route group", .{}, start, raw_input.len - start);
+
+                const len = end - start + 1;
+
+                const group_name = route_segment[start + 1 .. end];
+                if (strings.hasPrefixComptime(group_name, "."))
+                    return log.fail("Bun Bake currently does not support named slots and intercepted routes", .{}, start, len);
+
+                if (route_segment[start - 1] != '/' or (end + 1 < route_segment.len and route_segment[end + 1] != '/'))
+                    return log.fail("Route group marker must take up the entire file name", .{}, start, len);
+
+                const between = route_segment[i..start];
+                var it = std.mem.tokenizeScalar(u8, between, '/');
+                while (it.next()) |part|
+                    try parts.append(arena, .{ .text = part });
+                try parts.append(arena, .{ .group = group_name });
+
+                i = end + 1;
+            } else if (route_segment[start] == '@') {
+                const end = strings.indexOfCharPos(route_segment, ')', start + 1) orelse
+                    route_segment.len;
+                const len = end - start + 1;
+                return log.fail("Bun Bake currently does not support named slots and intercepted routes", .{}, start, len);
+            }
+        }
+        if (route_segment[i..].len > 0) {
+            var it = std.mem.tokenizeScalar(u8, route_segment[i..], '/');
+            while (it.next()) |part|
+                try parts.append(arena, .{ .text = part });
+        }
+        return parts.items;
+    }
+};
+
+const InsertError = error{ RouteCollision, OutOfMemory };
+const InsertKind = enum {
+    static,
+    dynamic,
+
+    fn Pattern(kind: InsertKind) type {
+        return switch (kind) {
+            .dynamic => EncodedPattern,
+            .static => StaticPattern,
+        };
+    }
+};
+
+/// Insert a new file, potentially creating a Route for that file.
+/// Moves ownership of EncodedPattern into the FrameworkRouter.
+///
+/// This function is designed so that any insertion order will create an
+/// equivalent routing tree, but it does not guarantee that route indices
+/// would match up if a different insertion order was picked.
+pub fn insert(
+    fr: *FrameworkRouter,
+    alloc: Allocator,
+    ty: Type.Index,
+    comptime insertion_kind: InsertKind,
+    pattern: insertion_kind.Pattern(),
+    file_kind: Route.FileKind,
+    file_path: []const u8,
+    ctx: InsertionContext,
+    /// When `error.RouteCollision` is returned, this is set to the existing file index.
+    out_colliding_file_id: *OpaqueFileId,
+) InsertError!void {
+    // The root route is the index of the type
+    const root_route = Type.rootRouteIndex(ty);
+
+    const new_route_index = brk: {
+        var input_it = pattern.iterate();
+        var current_part = input_it.next() orelse
+            break :brk root_route;
+
+        var route_index = root_route;
+        var route = fr.routePtr(root_route);
+        outer: while (true) {
+            var next = route.first_child.unwrap();
+            while (next) |current| {
+                const child = fr.routePtr(current);
+                if (current_part.eql(child.part)) {
+                    current_part = input_it.next() orelse
+                        break :brk current; // found it!
+
+                    route_index = current;
+                    route = fr.routePtr(current);
+                    continue :outer;
+                }
+                next = fr.routePtr(next.?).next_sibling.unwrap() orelse
+                    break;
+            }
+
+            // Must add to this child
+            var new_route_index = try fr.newRoute(alloc, .{
+                .part = current_part,
+                .type = ty,
+                .parent = route_index.toOptional(),
+                .first_child = .none,
+                .prev_sibling = Route.Index.Optional.init(next),
+                .next_sibling = .none,
+            });
+
+            if (next) |attach| {
+                fr.routePtr(attach).next_sibling = new_route_index.toOptional();
+            } else {
+                fr.routePtr(route_index).first_child = new_route_index.toOptional();
+            }
+
+            // Build each part out as another node in the routing graph. This makes
+            // inserting routes simpler to implement, but could technically be avoided.
+            while (input_it.next()) |next_part| {
+                const newer_route_index = try fr.newRoute(alloc, .{
+                    .part = next_part,
+                    .type = ty,
+                    .parent = new_route_index.toOptional(),
+                    .first_child = .none,
+                    .prev_sibling = Route.Index.Optional.init(next),
+                    .next_sibling = .none,
+                });
+                fr.routePtr(new_route_index).first_child = newer_route_index.toOptional();
+                new_route_index = newer_route_index;
+            }
+
+            break :brk new_route_index;
+        }
+    };
+
+    const file_id = try ctx.vtable.getFileIdForRouter(ctx.opaque_ctx, file_path, new_route_index, file_kind);
+
+    const new_route = fr.routePtr(new_route_index);
+    if (new_route.filePtr(file_kind).unwrap()) |existing| {
+        if (existing == file_id) {
+            return; // exact match already exists. Hot-reloading code hits this
+        }
+        out_colliding_file_id.* = existing;
+        return error.RouteCollision;
+    }
+    new_route.filePtr(file_kind).* = file_id.toOptional();
+
+    if (file_kind == .page) switch (insertion_kind) {
+        .static => {
+            const gop = try fr.static_routes.getOrPut(
+                alloc,
+                if (pattern.route_path.len == 0) "/" else pattern.route_path,
+            );
+            if (gop.found_existing) {
+                @panic("TODO: propagate aliased route error");
+            }
+            gop.value_ptr.* = new_route_index;
+        },
+        .dynamic => {
+            const gop = try fr.dynamic_routes.getOrPut(alloc, pattern);
+            if (gop.found_existing) {
+                @panic("TODO: propagate aliased route error");
+            }
+            gop.value_ptr.* = new_route_index;
+        },
+    };
+}
+
+/// An enforced upper bound of 64 unique patterns allows routing to use no heap allocation
+pub const MatchedParams = struct {
+    pub const max_count = 64;
+
+    params: std.BoundedArray(Entry, max_count),
+
+    pub const Entry = struct {
+        key: []const u8,
+        value: []const u8,
+    };
+};
+
+/// Fast enough for development to be seamless, but avoids building a
+/// complicated data structure that production uses to efficiently map
+/// urls to routes instead of this tree-traversal algorithm.
+pub fn matchSlow(fr: *FrameworkRouter, path: []const u8, params: *MatchedParams) ?Route.Index {
+    params.* = .{ .params = .{} };
+
+    bun.assert(path[0] == '/');
+    if (fr.static_routes.get(path)) |static| {
+        return static;
+    }
+
+    for (fr.dynamic_routes.keys(), 0..) |pattern, i| {
+        if (pattern.matches(path, params)) {
+            return fr.dynamic_routes.values()[i];
+        }
+    }
+
+    return null;
+}
+
+pub fn routePtr(fr: *FrameworkRouter, i: Route.Index) *Route {
+    return &fr.routes.items[i.get()];
+}
+
+pub fn typePtr(fr: *FrameworkRouter, i: Type.Index) *Type {
+    return &fr.types[i.get()];
+}
+
+fn newRoute(fr: *FrameworkRouter, alloc: Allocator, route_data: Route) !Route.Index {
+    const i = fr.routes.items.len;
+    try fr.routes.append(alloc, route_data);
+    return Route.Index.init(@intCast(i));
+}
+
+fn newEdge(fr: *FrameworkRouter, alloc: Allocator, edge_data: Route.Edge) !Route.Edge.Index {
+    if (fr.freed_edges.popOrNull()) |i| {
+        fr.edges.items[i.get()] = edge_data;
+        return i;
+    } else {
+        const i = fr.edges.items.len;
+        try fr.edges.append(alloc, edge_data);
+        return Route.Edge.Index.init(i);
+    }
+}
+
+const PatternParseError = error{InvalidRoutePattern};
+
+/// Non-allocating single message log, specialized for the messages from the route pattern parsers.
+pub const TinyLog = struct {
+    msg: std.BoundedArray(u8, 512 + std.fs.max_path_bytes),
+    cursor_at: u32,
+    cursor_len: u32,
+
+    pub const empty: TinyLog = .{ .cursor_at = std.math.maxInt(u32), .cursor_len = 0, .msg = .{} };
+
+    pub fn fail(log: *TinyLog, comptime fmt: []const u8, args: anytype, cursor_at: usize, cursor_len: usize) PatternParseError {
+        log.msg.len = @intCast(if (std.fmt.bufPrint(&log.msg.buffer, fmt, args)) |slice| slice.len else |_| brk: {
+            // truncation should never happen because the buffer is HUGE. handle it anyways
+            @memcpy(log.msg.buffer[log.msg.buffer.len - 3 ..], "...");
+            break :brk log.msg.buffer.len;
+        });
+        log.cursor_at = @intCast(cursor_at);
+        log.cursor_len = @intCast(cursor_len);
+        return PatternParseError.InvalidRoutePattern;
+    }
+};
+
+/// Interface for connecting FrameworkRouter to another codebase
+pub const InsertionContext = struct {
+    opaque_ctx: *anyopaque,
+    vtable: *const VTable,
+    const VTable = struct {
+        getFileIdForRouter: *const fn (*anyopaque, abs_path: []const u8, associated_route: Route.Index, kind: Route.FileKind) bun.OOM!OpaqueFileId,
+    };
+    pub fn wrap(comptime T: type, ctx: *T) InsertionContext {
+        const wrapper = struct {
+            fn getFileIdForRouter(opaque_ctx: *anyopaque, abs_path: []const u8, associated_route: Route.Index, kind: Route.FileKind) bun.OOM!OpaqueFileId {
+                const cast_ctx: *T = @alignCast(@ptrCast(opaque_ctx));
+                return try cast_ctx.getFileIdForRouter(abs_path, associated_route, kind);
+            }
+        };
+        return .{
+            .opaque_ctx = ctx,
+            .vtable = comptime &.{
+                .getFileIdForRouter = &wrapper.getFileIdForRouter,
+            },
+        };
+    }
+};
+
+pub fn scan(
+    fw: *FrameworkRouter,
+    alloc: Allocator,
+    ty: Type.Index,
+    r: *Resolver,
+    ctx: InsertionContext,
+) !void {
+    const t = &fw.types[ty.get()];
+    bun.assert(!strings.hasSuffixComptime(t.abs_root, "/"));
+    bun.assert(std.fs.path.isAbsolute(t.abs_root));
+    const root_info = try r.readDirInfo(t.abs_root) orelse
+        return error.RootDirMissing;
+    var arena_state = std.heap.ArenaAllocator.init(alloc);
+    defer arena_state.deinit();
+    try fw.scanInner(alloc, t, ty, r, root_info, &arena_state, ctx);
+}
+
+fn scanInner(
+    fr: *FrameworkRouter,
+    alloc: Allocator,
+    t: *const Type,
+    t_index: Type.Index,
+    r: *Resolver,
+    dir_info: *const DirInfo,
+    arena_state: *std.heap.ArenaAllocator,
+    ctx: InsertionContext,
+) !void {
+    const fs = r.fs;
+    const fs_impl = &fs.fs;
+
+    if (dir_info.getEntriesConst()) |entries| {
+        var it = entries.data.iterator();
+        outer: while (it.next()) |entry| {
+            const file = entry.value_ptr.*;
+            const base = file.base();
+            switch (file.kind(fs_impl, false)) {
+                .dir => {
+                    if (t.ignore_underscores and bun.strings.hasPrefixComptime(base, "_"))
+                        continue :outer;
+
+                    for (t.ignore_dirs) |banned_dir| {
+                        if (bun.strings.eqlLong(base, banned_dir, true)) {
+                            continue :outer;
+                        }
+                    }
+
+                    if (r.readDirInfoIgnoreError(fs.abs(&.{ file.dir, file.base() }))) |child_info| {
+                        try fr.scanInner(alloc, t, t_index, r, child_info, arena_state, ctx);
+                    }
+                },
+                .file => {
+                    const ext = std.fs.path.extension(base);
+
+                    if (t.extensions.len > 0) {
+                        for (t.extensions) |allowed_ext| {
+                            if (strings.eql(ext, allowed_ext)) break;
+                        } else continue :outer;
+                    }
+
+                    var rel_path_buf: bun.PathBuffer = undefined;
+                    var rel_path = bun.path.relativeNormalizedBuf(
+                        rel_path_buf[1..],
+                        t.abs_root,
+                        fs.abs(&.{ file.dir, file.base() }),
+                        .posix,
+                        true,
+                    );
+                    rel_path_buf[0] = '/';
+                    rel_path = rel_path_buf[0 .. rel_path.len + 1];
+                    var log = TinyLog.empty;
+                    defer _ = arena_state.reset(.retain_capacity);
+                    const parsed = (t.style.parse(rel_path, ext, &log, arena_state.allocator()) catch
+                        @panic("TODO: propagate error message")) orelse continue :outer;
+
+                    var static_total_len: usize = 0;
+                    var param_count: usize = 0;
+                    for (parsed.parts) |part| {
+                        switch (part) {
+                            .text => |data| static_total_len += 1 + data.len,
+
+                            .param,
+                            .catch_all,
+                            .catch_all_optional,
+                            => param_count += 1,
+
+                            .group => {},
+                        }
+                    }
+
+                    if (param_count > 64) {
+                        @panic("TODO: propagate error for more than 64 params");
+                    }
+
+                    if (parsed.kind == .page and t.ignore_underscores and bun.strings.hasPrefixComptime(base, "_"))
+                        continue :outer;
+
+                    const result = switch (param_count > 0) {
+                        inline else => |has_dynamic_comptime| result: {
+                            const pattern = if (has_dynamic_comptime)
+                                try EncodedPattern.initFromParts(parsed.parts, alloc)
+                            else static_route: {
+                                const allocation = try bun.default_allocator.alloc(u8, static_total_len);
+                                var s = std.io.fixedBufferStream(allocation);
+                                for (parsed.parts) |part|
+                                    switch (part) {
+                                        .text => |data| {
+                                            _ = s.write("/") catch unreachable;
+                                            _ = s.write(data) catch unreachable;
+                                        },
+                                        .group => {},
+                                        .param, .catch_all, .catch_all_optional => unreachable,
+                                    };
+                                bun.assert(s.getWritten().len == allocation.len);
+                                break :static_route StaticPattern{ .route_path = allocation };
+                            };
+                            var out_colliding_file_id: OpaqueFileId = undefined;
+
+                            break :result fr.insert(
+                                alloc,
+                                t_index,
+                                if (has_dynamic_comptime) .dynamic else .static,
+                                pattern,
+                                switch (parsed.kind) {
+                                    .page => .page,
+                                    .layout => .layout,
+                                    .extra => @panic("TODO: extra files"),
+                                },
+                                fs.abs(&.{ file.dir, file.base() }),
+                                ctx,
+                                &out_colliding_file_id,
+                            );
+                        },
+                    };
+
+                    result catch @panic("TODO: propagate error message");
+                },
+            }
+        }
+
+        //
+    }
+}
+
+/// This binding is currently only intended for testing FrameworkRouter, and not
+/// production usage. It uses a slower but easier to use pattern for object
+/// creation. A production-grade JS api would be able to re-use objects.
+pub const JSFrameworkRouter = struct {
+    pub const codegen = JSC.Codegen.JSFrameworkFileSystemRouter;
+    pub usingnamespace codegen;
+
+    files: std.ArrayListUnmanaged(bun.String),
+    router: FrameworkRouter,
+
+    const validators = bun.JSC.Node.validators;
+
+    pub fn getBindings(global: *JSC.JSGlobalObject) JSC.JSValue {
+        return global.createObjectFromStruct(.{
+            .parseRoutePattern = global.createHostFunction("parseRoutePattern", parseRoutePattern, 1),
+            .FrameworkRouter = codegen.getConstructor(global),
+        }).toJS();
+    }
+
+    pub fn constructor(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) !*JSFrameworkRouter {
+        const opts = callframe.argumentsAsArray(1)[0];
+        if (!opts.isObject())
+            return global.throwInvalidArguments2("FrameworkRouter needs an object as it's first argument", .{});
+
+        const root = try opts.getOptional(global, "root", bun.String.Slice) orelse
+            return global.throwInvalidArguments2("Missing options.root", .{});
+        defer root.deinit();
+
+        const style = try validators.validateStringEnum(
+            Style,
+            global,
+            try opts.getOptional(global, "style", JSValue) orelse .undefined,
+            "style",
+            .{},
+        );
+
+        const abs_root = try bun.default_allocator.dupe(u8, bun.strings.withoutTrailingSlash(
+            bun.path.joinAbs(bun.fs.FileSystem.instance.top_level_dir, .auto, root.slice()),
+        ));
+        errdefer bun.default_allocator.free(abs_root);
+
+        const types = try bun.default_allocator.dupe(Type, &.{.{
+            .abs_root = abs_root,
+            .ignore_underscores = false,
+            .extensions = &.{ ".tsx", ".ts", ".jsx", ".js" },
+            .style = style,
+            // Unused by JSFrameworkRouter
+            .client_file = undefined,
+            .server_file = undefined,
+            .server_file_string = undefined,
+        }});
+        errdefer bun.default_allocator.free(types);
+
+        const jsfr = bun.new(JSFrameworkRouter, .{
+            .router = try FrameworkRouter.initEmpty(types, bun.default_allocator),
+            .files = .{},
+        });
+
+        jsfr.router.scan(
+            bun.default_allocator,
+            Type.Index.init(0),
+            &global.bunVM().bundler.resolver,
+            InsertionContext.wrap(JSFrameworkRouter, jsfr),
+        ) catch |err| {
+            global.throwError(err, "while scanning route list");
+            return error.JSError;
+        };
+
+        return jsfr;
+    }
+
+    pub fn match(jsfr: *JSFrameworkRouter, global: *JSGlobalObject, callframe: *JSC.CallFrame) !JSValue {
+        const path_js = callframe.argumentsAsArray(1)[0];
+        const path_str = try path_js.toBunString2(global);
+        defer path_str.deref();
+        const path_slice = path_str.toSlice(bun.default_allocator);
+        defer path_slice.deinit();
+
+        var params_out: MatchedParams = undefined;
+        if (jsfr.router.matchSlow(path_slice.slice(), &params_out)) |index| {
+            var sfb = std.heap.stackFallback(4096, bun.default_allocator);
+            const alloc = sfb.get();
+
+            return global.createObjectFromStruct(.{
+                .params = if (params_out.params.len > 0) params: {
+                    const obj = JSValue.createEmptyObject(global, params_out.params.len);
+                    for (params_out.params.slice()) |param| {
+                        const value = bun.String.createUTF8(param.value);
+                        defer value.deref();
+                        obj.put(global, param.key, value.toJS(global));
+                    }
+                    break :params obj;
+                } else .null,
+                .route = try jsfr.routeToJsonInverse(global, index, alloc),
+            }).toJS();
+        }
+
+        return .null;
+    }
+
+    pub fn toJSON(jsfr: *JSFrameworkRouter, global: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+        _ = callframe;
+
+        var sfb = std.heap.stackFallback(4096, bun.default_allocator);
+        const alloc = sfb.get();
+
+        return jsfr.routeToJson(global, Route.Index.init(0), alloc);
+    }
+
+    fn routeToJson(jsfr: *JSFrameworkRouter, global: *JSGlobalObject, route_index: Route.Index, allocator: Allocator) !JSValue {
+        const route = jsfr.router.routePtr(route_index);
+        return global.createObjectFromStruct(.{
+            .part = try partToJS(global, route.part, allocator),
+            .page = jsfr.fileIdToJS(global, route.file_page),
+            .layout = jsfr.fileIdToJS(global, route.file_layout),
+            // .notFound = jsfr.fileIdToJS(global, route.file_not_found),
+            .children = brk: {
+                var len: usize = 0;
+                var next = route.first_child.unwrap();
+                while (next) |r| : (next = jsfr.router.routePtr(r).next_sibling.unwrap())
+                    len += 1;
+                const arr = JSValue.createEmptyArray(global, len);
+                next = route.first_child.unwrap();
+                var i: u32 = 0;
+                while (next) |r| : (next = jsfr.router.routePtr(r).next_sibling.unwrap()) {
+                    arr.putIndex(global, i, try routeToJson(jsfr, global, r, allocator));
+                    i += 1;
+                }
+                break :brk arr;
+            },
+        }).toJS();
+    }
+
+    fn routeToJsonInverse(jsfr: *JSFrameworkRouter, global: *JSGlobalObject, route_index: Route.Index, allocator: Allocator) !JSValue {
+        const route = jsfr.router.routePtr(route_index);
+        return global.createObjectFromStruct(.{
+            .part = try partToJS(global, route.part, allocator),
+            .page = jsfr.fileIdToJS(global, route.file_page),
+            .layout = jsfr.fileIdToJS(global, route.file_layout),
+            // .notFound = jsfr.fileIdToJS(global, route.file_not_found),
+            .parent = if (route.parent.unwrap()) |parent|
+                try routeToJsonInverse(jsfr, global, parent, allocator)
+            else
+                .null,
+        }).toJS();
+    }
+
+    pub fn finalize(this: *JSFrameworkRouter) void {
+        this.files.deinit(bun.default_allocator);
+        this.router.deinit(bun.default_allocator);
+        bun.default_allocator.free(this.router.types);
+        bun.destroy(this);
+    }
+
+    pub fn parseRoutePattern(global: *JSGlobalObject, frame: *CallFrame) !JSValue {
+        var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+        defer arena.deinit();
+        const alloc = arena.allocator();
+
+        if (frame.argumentsCount() < 2)
+            return global.throwInvalidArguments2("parseRoutePattern takes two arguments", .{});
+
+        const style_js, const filepath_js = frame.argumentsAsArray(2);
+        const filepath = try filepath_js.toSlice2(global, alloc);
+        defer filepath.deinit();
+        const style_string = try style_js.toSlice2(global, alloc);
+        defer style_string.deinit();
+
+        const style = std.meta.stringToEnum(Style, style_string.slice()) orelse
+            return global.throwInvalidArguments2("unknown router style {}", .{bun.fmt.quote(style_string.slice())});
+
+        var log = TinyLog.empty;
+        const parsed = style.parse(filepath.slice(), std.fs.path.extension(filepath.slice()), &log, alloc) catch |err| switch (err) {
+            error.InvalidRoutePattern => {
+                global.throw("{s} ({d}:{d})", .{ log.msg.slice(), log.cursor_at, log.cursor_len });
+                return error.JSError;
+            },
+            else => |e| return e,
+        } orelse
+            return .null;
+
+        var rendered = try std.ArrayList(u8).initCapacity(alloc, filepath.slice().len);
+        for (parsed.parts) |part| try part.toStringForInternalUse(rendered.writer());
+
+        var out = bun.String.init(rendered.items);
+        const obj = JSValue.createEmptyObject(global, 2);
+        obj.put(global, "kind", bun.String.static(@tagName(parsed.kind)).toJS(global));
+        obj.put(global, "pattern", out.transferToJS(global));
+        return obj;
+    }
+
+    fn encodedPatternToJS(global: *JSGlobalObject, pattern: EncodedPattern, temp_allocator: Allocator) !JSValue {
+        var rendered = try std.ArrayList(u8).initCapacity(temp_allocator, pattern.data.len);
+        defer rendered.deinit();
+        var it = pattern.iterate();
+        while (it.next()) |part| try part.toStringForInternalUse(rendered.writer());
+        var str = bun.String.createUTF8(rendered.items);
+        return str.transferToJS(global);
+    }
+
+    fn partToJS(global: *JSGlobalObject, part: Part, temp_allocator: Allocator) !JSValue {
+        var rendered = std.ArrayList(u8).init(temp_allocator);
+        defer rendered.deinit();
+        try part.toStringForInternalUse(rendered.writer());
+        var str = bun.String.createUTF8(rendered.items);
+        return str.transferToJS(global);
+    }
+
+    pub fn getFileIdForRouter(jsfr: *JSFrameworkRouter, abs_path: []const u8, _: Route.Index, _: Route.FileKind) !OpaqueFileId {
+        try jsfr.files.append(bun.default_allocator, bun.String.createUTF8(abs_path));
+        return OpaqueFileId.init(@intCast(jsfr.files.items.len - 1));
+    }
+
+    pub fn fileIdToJS(jsfr: *JSFrameworkRouter, global: *JSGlobalObject, id: OpaqueFileId.Optional) JSValue {
+        return jsfr.files.items[(id.unwrap() orelse return .null).get()].toJS(global);
+    }
+};
+
+const std = @import("std");
+const mem = std.mem;
+const Allocator = mem.Allocator;
+
+const bun = @import("root").bun;
+const strings = bun.strings;
+const Resolver = bun.resolver.Resolver;
+const DirInfo = bun.resolver.DirInfo;
+
+const JSC = bun.JSC;
+const JSValue = JSC.JSValue;
+const JSGlobalObject = JSC.JSGlobalObject;
+const CallFrame = JSC.CallFrame;
diff --git a/src/bake/bake.d.ts b/src/bake/bake.d.ts
index 3e7b0d9473ecfe..17212629ba1151 100644
--- a/src/bake/bake.d.ts
+++ b/src/bake/bake.d.ts
@@ -1,75 +1,129 @@
-declare module "bun" {
-  declare function wipDevServerExpectHugeBreakingChanges(options: Bake.Options): never;
+// This API is under heavy development. See #bake in the Bun Discord for more info.
+// Definitions that are commented out are planned but not implemented.
+//
+// To use, add a TypeScript reference comment mentioning this file:
+// /// <reference path="/path/to/bun/src/bake/bake.d.ts" />
 
+declare module "bun" {
   type Awaitable<T> = T | Promise<T>;
 
   declare namespace Bake {
     interface Options {
+      /** Will be replaced by fileSystemRouters */
+      routes: {}[];
+
       /**
-       * Bun provides built-in support for using React as a framework by
-       * passing 'react-server-components' as the framework name.
+       * Bun provides built-in support for using React as a framework by passing
+       * 'react' as the framework name. Otherwise, frameworks are config objects.
        *
-       * Has external dependencies:
+       * External dependencies:
        * ```
        * bun i react@experimental react-dom@experimental react-server-dom-webpack@experimental react-refresh@experimental
        * ```
        */
-      framework: Framework | "react-server-components";
+      framework: Framework | "react";
+      // Note: To contribute to 'bun-framework-react', it can be run from this file:
+      // https://github.com/oven-sh/bun/blob/main/src/bake/bun-framework-react/index.ts
 
       /**
-       * Route patterns must be statically known.
-       * TODO: Static at dev-server start is bad and this API must be revisited
+       * A subset of the options from Bun.build can be configured. Keep in mind,
+       * your framework may set different defaults.
+       *
+       * @default {}
        */
-      routes: Record<RoutePattern, RouteOptions>;
-
-      // TODO: many other options
+      bundlerOptions?: BundlerOptions | undefined;
     }
 
+    /** Bake only allows a subset of options from `Bun.build` */
+    type BuildConfigSubset = Pick<
+      BuildConfig,
+      "conditions" | "plugins" | "define" | "loader" | "ignoreDCEAnnotations" | "drop"
+      // - format is not allowed because it is set to an internal "hmr" format
+      // - entrypoints/outfile/outdir doesnt make sense to set
+      // - disabling sourcemap is not allowed because it makes code impossible to debug
+      // - enabling minifyIdentifiers in dev is not allowed because some generated code does not support it
+      // - publicPath is set elsewhere (TODO:)
+      // - emitDCEAnnotations is not useful
+      // - banner and footer do not make sense in these multi-file builds
+      // - experimentalCss cannot be disabled
+      // - disabling external would make it exclude imported files.
+
+      // TODO: jsx customization
+      // TODO: chunk naming
+    >;
+
+    type BundlerOptions = BuildConfigSubset & {
+      /** Customize the build options of the client-side build */
+      client?: BuildConfigSubset;
+      /** Customize the build options of the server build */
+      server?: BuildConfigSubset;
+      /** Customize the build options of the separated SSR graph */
+      ssr?: BuildConfigSubset;
+    };
+
     /**
      * A "Framework" in our eyes is simply a set of bundler options that a
      * framework author would set in order to integrate framework code with the
      * application. Many of the configuration options are paths, which are
-     * resolved as import specifiers. The first thing the bundler does is
-     * ensure that all import specifiers are fully resolved.
+     * resolved as import specifiers.
      */
     interface Framework {
       /**
-       * This file is the true entrypoint of the server application. This module
-       * must `export default` a fetch function, which takes a request and the
-       * bundled route module, and returns a response. See `ServerEntryPoint`
-       *
-       * When `serverComponents` is configured, this can access the component
-       * manifest using the special 'bun:bake/server' import:
-       *
-       *     import { serverManifest } from 'bun:bake/server'
+       * Customize the bundler options. Plugins in this array are merged
+       * with any plugins the user has.
+       * @default {}
+       */
+      bundlerOptions?: BundlerOptions | undefined;
+      /**
+       * The translation of files to routes is unopinionated and left
+       * to framework authors. This interface allows most flexibility
+       * between the already established conventions while allowing
+       * new ideas to be explored too.
+       * @default []
        */
-      serverEntryPoint: ImportSource;
+      fileSystemRouterTypes?: FrameworkFileSystemRouterType[];
       /**
-       * This file is the true entrypoint of the client application.
+       * A list of directories that should be served statically. If the directory
+       * does not exist in the user's project, it is ignored.
        *
-       * When `serverComponents` is configured, this can access the component
-       * manifest using the special 'bun:bake/client' import:
+       * Example: 'public' or 'static'
        *
-       *     import { clientManifest } from 'bun:bake/client'
+       * Different frameworks have different opinions, some use 'static', some
+       * use 'public'.
+       * @default []
        */
-      clientEntryPoint: ImportSource;
+      staticRouters?: Array<StaticRouter> | undefined;
       /**
-       * Add extra modules
+       * Add extra modules. This can be used to, for example, replace `react`
+       * with a different resolution.
+       *
+       * Internally, Bun's `react-server-components` framework uses this to
+       * embed its files in the `bun` binary.
+       * @default {}
        */
-      builtInModules?: Record<string, BuiltInModule>;
+      builtInModules?: BuiltInModule[] | undefined;
       /**
        * Bun offers integration for React's Server Components with an
        * interface that is generic enough to adapt to any framework.
+       * @default undefined
        */
       serverComponents?: ServerComponentsOptions | undefined;
       /**
        * While it is unlikely that Fast Refresh is useful outside of
        * React, it can be enabled regardless.
+       * @default false
        */
-      reactFastRefresh?: ReactFastRefreshOptions | true | undefined;
+      reactFastRefresh?: boolean | ReactFastRefreshOptions | undefined;
+
+      // /**
+      //  * Called after the list of routes is updated. This can be used to
+      //  * implement framework-specific features like `.d.ts` generation:
+      //  * https://nextjs.org/docs/app/building-your-application/configuring/typescript#statically-typed-links
+      //  */
+      // onRouteListUpdate?: (routes: OnRouteListUpdateItem) => void;
     }
 
-    type BuiltInModule = { code: string } | { path: string };
+    type BuiltInModule = { import: string; code: string } | { import: string; path: string };
 
     /**
      * A high-level overview of what server components means exists
@@ -100,7 +154,7 @@ declare module "bun" {
        * To cross from the server graph to the SSR graph, use the bun_bake_graph
        * import attribute:
        *
-       *     import * as ReactDOM from 'react-dom/server' with { bun_bake_graph: 'ssr' };
+       *     import * as ReactDOM from 'react-dom/server' with { bunBakeGraph: 'ssr' };
        *
        * Since these models are so subtley different, there is no default value
        * provided for this.
@@ -130,14 +184,15 @@ declare module "bun" {
        *
        * Additionally, the bundler will assemble a component manifest to be used
        * during rendering.
+       * @default "registerClientReference"
        */
-      serverRegisterClientReferenceExport: string | undefined;
+      serverRegisterClientReferenceExport?: string | undefined;
       // /**
       //  * Allow creating client components inside of server-side files by using "use client"
       //  * as the first line of a function declaration. This is useful for small one-off
       //  * interactive components. This is behind a flag because it is not a feature of
       //  * React or Next.js, but rather is implemented because it is possible to.
-      //  * 
+      //  *
       //  * The client versions of these are tree-shaked extremely aggressively: anything
       //  * not referenced by the function body will be removed entirely.
       //  */
@@ -146,52 +201,235 @@ declare module "bun" {
 
     /** Customize the React Fast Refresh transform. */
     interface ReactFastRefreshOptions {
-      /** 
+      /**
        * This import has four exports, mirroring "react-refresh/runtime":
-       * 
+       *
        * `injectIntoGlobalHook(window): void`
        * Called on first startup, before the user entrypoint.
-       * 
+       *
        * `register(component, uniqueId: string): void`
        * Called on every function that starts with an uppercase letter. These
        * may or may not be components, but they are always functions.
-       * 
+       *
        * `createSignatureFunctionForTransform(): ReactRefreshSignatureFunction`
        * TODO: document. A passing no-op for this api is `return () => {}`
-       * 
+       *
        * @default "react-refresh/runtime"
        */
       importSource: ImportSource | undefined;
     }
 
-    type ReactRefreshSignatureFunction = () => void | ((func: Function, hash: string, force?: bool, customHooks?: () => Function[]) => void);
+    type ReactRefreshSignatureFunction = () =>
+      | void
+      | ((func: Function, hash: string, force?: bool, customHooks?: () => Function[]) => void);
 
-    /// Will be resolved from the point of view of the framework user's project root
-    /// Examples: `react-dom`, `./entry_point.tsx`, `/absolute/path.js`
-    type ImportSource = string;
+    /** This API is similar, but unrelated to `Bun.FileSystemRouter`  */
+    interface FrameworkFileSystemRouterType {
+      /**
+       * Relative to project root. For example: `src/pages`.
+       */
+      root: string;
+      /**
+       * The prefix to serve this directory on.
+       * @default "/"
+       */
+      prefix?: string | undefined;
+      /**
+       * This file is the entrypoint of the server application. This module
+       * must `export default` a fetch function, which takes a request and the
+       * bundled route module, and returns a response. See `ServerEntryPoint`
+       *
+       * When `serverComponents` is configured, this can access the component
+       * manifest using the special 'bun:bake/server' import:
+       *
+       *     import { serverManifest } from 'bun:bake/server'
+       */
+      serverEntryPoint: ImportSource<ServerEntryPoint>;
+      /**
+       * This file is the true entrypoint of the client application. If null,
+       * a client will not be bundled, and the route will not receive bundling
+       * for client-side interactivity.
+       */
+      clientEntryPoint?: ImportSource<ClientEntryPoint> | undefined;
+      /**
+       * Do not traverse into directories and files that start with an `_`.  Do
+       * not index pages that start with an `_`. Does not prevent stuff like
+       * `_layout.tsx` from being recognized.
+       */
+      ignoreUnderscores?: boolean;
+      /**
+       * @default ["node_modules", ".git"]
+       */
+      ignoreDirs?: string[];
+      /**
+       * Extensions to match on.
+       * '*' - any extension
+       */
+      extensions: string[] | "*";
+      /**
+       * 'nextjs-app' builds routes out of directories with `page.tsx` and `layout.tsx`
+       * 'nextjs-pages' builds routes out of any `.tsx` file and layouts with `_layout.tsx`.
+       *
+       * Eventually, an API will be added to add custom styles.
+       */
+      style: "nextjs-pages" | "nextjs-app-ui" | "nextjs-app-routes" | CustomFileSystemRouterFunction;
+      /**
+       * If true, this will track route layouts and provide them as an array during SSR.
+       * @default false
+       */
+      layouts?: boolean | undefined;
+      // /**
+      //  * If true, layouts act as navigation endpoints. This can be used to
+      //  * implement Remix.run's router design, where `hello._index` and `hello`
+      //  * are the same URL, but an allowed collision.
+      //  *
+      //  * @default false
+      //  */
+      // navigatableLayouts?: boolean | undefined;
+      // /**
+      //  * Controls how the route entry point is bundled with regards to server components:
+      //  * - server-component: Default server components.
+      //  * - client-boundary: As if "use client" was used on every route.
+      //  * - disabled: As if server components was completely disabled.
+      //  *
+      //  * @default "server-component" if serverComponents is enabled, "disabled" otherwise
+      //  */
+      // serverComponentsMode?: "server-component" | "client-boundary" | "disabled";
+    }
+
+    type StaticRouter =
+      /** Alias for { source: ..., prefix: "/" } */
+      | string
+      | {
+          /** The source directory to observe. */
+          source: string;
+          /** The prefix to serve this directory on. */
+          prefix: string;
+        };
+
+    /**
+     * Bun will call this function for every found file. This
+     * function classifies each file's role in the file system routing.
+     */
+    type CustomFileSystemRouterFunction = (candidatePath: string) => CustomFileSystemRouterResult;
+
+    type CustomFileSystemRouterResult =
+      /** Skip this file */
+      | undefined
+      | null
+      /**
+       * Use this file as a route. Routes may nest, where a framework
+       * can use parent routes to implement layouts.
+       */
+      | {
+          /**
+           * Route pattern can include `:param` for parameters, '*' for
+           * catch-all, and '*?' for optional catch-all. Parameters must take
+           * the full component of a path segment. Parameters cannot have
+           * constraints at this moment.
+           */
+          pattern: string;
+          type: "route" | "layout" | "extra";
+        };
+
+    /**
+     * Will be resolved from the point of view of the framework user's project root
+     * Examples: `react-dom`, `./entry_point.tsx`, `/absolute/path.js`
+     */
+    type ImportSource<T = unknown> = string;
 
     interface ServerEntryPoint {
       /**
-       * The framework implementation decides and enforces the shape
-       * of the route module. Bun passes it as an opaque value.
+       * Bun passes the route's module as an opaque argument `routeModule`. The
+       * framework implementation decides and enforces the shape of the module.
+       *
+       * A common pattern would be to enforce the object is
+       * `{ default: ReactComponent }`
+       */
+      render: (request: Request, routeMetadata: RouteMetadata) => Awaitable<Response>;
+      /**
+       * Prerendering does not use a request, and is allowed to generate
+       * multiple responses. This is used for static site generation, but not
+       * not named `staticRender` as it is invoked during a dynamic build to
+       * allow deterministic routes to be prerendered.
+       *
+       * Note that `import.meta.env.STATIC` will be inlined to true during
+       * a static build.
+       */
+      prerender?: (routeMetadata: RouteMetadata) => Awaitable<PrerenderResult | null>;
+      // TODO: prerenderWithoutProps (for partial prerendering)
+      /**
+       * For prerendering routes with dynamic parameters, such as `/blog/:slug`,
+       * this will be called to get the list of parameters to prerender. This
+       * allows static builds to render every page at build time.
+       *
+       * `getParams` may return an object with an array of pages. For example,
+       * to generate two pages, `/blog/hello` and `/blog/world`:
+       *
+       *      return {
+       *          pages: [{ slug: 'hello' }, { slug: 'world' }],
+       *          exhaustive: true,
+       *      }
+       *
+       * "exhaustive" tells Bun that the list is complete. If it is not, a
+       * static site cannot be generated as it would otherwise be missing
+       * routes. A non-exhaustive list can speed up build times by only
+       * specifying a few important pages (such as 10 most recent), leaving
+       * the rest to be generated on-demand at runtime.
+       *
+       * To stream results, `getParams` may return an async iterator, which
+       * Bun will start rendering as more parameters are provided:
+       *
+       *     export async function* getParams(meta: Bake.ParamsMetadata) {
+       *         yield { slug: await fetchSlug() };
+       *         yield { slug: await fetchSlug() };
+       *         return { exhaustive: false };
+       *     }
        */
-      default: (request: Request, routeModule: unknown, routeMetadata: RouteMetadata) => Awaitable<Response>;
+      getParams?: (paramsMetadata: ParamsMetadata) => Awaitable<ParamsResult>;
       /**
-       * Static rendering does not take a response in, and can generate
-       * multiple output files. Note that `import.meta.env.STATIC` will
-       * be inlined to true during a static build.
+       * When a dynamic build uses static assets, Bun can map content types in the
+       * user's `Accept` header to the different static files.
        */
-      staticRender: (routeModule: unknown, routeMetadata: RouteMetadata) => Awaitable<Record<string, Blob | ArrayBuffer>>;
+      contentTypeToStaticFile?: Record<string, string>;
+    }
+
+    type GetParamIterator =
+      | AsyncIterable<Record<string, string>, GetParamsFinalOpts>
+      | Iterable<Record<string, string>, GetParamsFinalOpts>
+      | ({ pages: Array<Record<String, String>> } & GetParamsFinalOpts);
+
+    type GetParamsFinalOpts = void | null | {
+      /**
+       * @default true
+       */
+      exhaustive?: boolean | undefined;
+    };
+
+    interface PrerenderResult {
+      files?: Record<string, Blob | NodeJS.TypedArray | ArrayBufferLike | string | Bun.BlobPart[]>;
+      // /**
+      //  * For dynamic builds, `partialData` will be provided to `render` to allow
+      //  * to implement Partial Pre-rendering, a technique where the a page shell
+      //  * is rendered first, and the rendering is resumed. The bytes passed
+      //  * here will be passed to the `render` function as `partialData`.
+      //  */
+      // partialData?: Uint8Array;
+
+      // TODO: support incremental static regeneration + stale while revalidate here
+      // cache: unknown;
     }
 
     interface ClientEntryPoint {
       /**
        * Called when server-side code is changed. This can be used to fetch a
-       * non-html version of the updated page to perform a faster reload.
+       * non-html version of the updated page to perform a faster reload. If
+       * this function does not exist or throws, the client will perform a
+       * hard reload.
        *
        * Tree-shaken away in production builds.
        */
-      onServerSideReload?: () => void;
+      onServerSideReload?: () => Promise<void> | void;
     }
 
     /**
@@ -199,86 +437,119 @@ declare module "bun" {
      * is not safe to mutate it at all.
      */
     interface RouteMetadata {
+      /**
+       * The loaded module of the page itself.
+       */
+      readonly pageModule: any;
+      /**
+       * The loaded module of all of the route layouts. The first one is the
+       * inner-most, the last is the root layout.
+       *
+       * An example of converting the layout list into a nested JSX structure:
+       *     const Page = meta.pageModule.default;
+       *     let route = <Page />
+       *     for (const layout of meta.layouts) {
+       *       const Layout = layout.default;
+       *       route = <Layout>{route}</Layout>;
+       *     }
+       */
+      readonly layouts: ReadonlyArray<any>;
+      /** Received route params. `null` if the route does not take params */
+      readonly params: null | Record<string, string>;
       /**
        * A list of js files that the route will need to be interactive.
        */
       readonly scripts: ReadonlyArray<string>;
       /**
-       * A list of css files that the route will need to be styled.
+       * A list of js files that should be preloaded.
+       *
+       *   <link rel="modulepreload" href="..." />
        */
-      readonly styles: ReadonlyArray<string>;
+      readonly modulepreload: ReadonlyArray<string>;
       /**
-       * Can be used by the framework to mention the route file. Only provided in
-       * development mode to prevent leaking these details into production
-       * builds.
+       * A list of css files that the route will need to be styled.
        */
-      devRoutePath?: string;
+      readonly styles: ReadonlyArray<string>;
+    }
+
+    /**
+     * This object and it's children may be re-used between invocations, so it
+     * is not safe to mutate it at all.
+     */
+    interface ParamsMetadata {
+      readonly pageModule: any;
+      readonly layouts: ReadonlyArray<any>;
     }
   }
 
-  // declare class Bake {
-  //   constructor(options: Bake.Options);
-  // }
+  interface GenericServeOptions {
+    /** Add a fullstack web app to this server using Bun Bake */
+    app?: Bake.Options | undefined;
+  }
 }
 
 declare module "bun:bake/server" {
   // NOTE: The format of these manifests will likely be customizable in the future.
 
-  /**
-   * Entries in this manifest can be loaded by using dynamic `await import()` or
-   * `require`. The bundler always ensures that all modules are ready on the server.
-   */
-  declare const clientManifest: ReactClientManifest;
   /**
    * This follows the requirements for React's Server Components manifest, which
-   * does not actually include usable module specifiers. Calling `import()` on
-   * these specifiers wont work, but they will work client-side. Use
-   * `clientManifest` on the server for SSR.
+   * is a mapping of component IDs to the client-side file it is exported in.
+   * The specifiers from here are to be imported in the client.
+   *
+   * To perform SSR with client components, see `clientManifest`
    */
   declare const serverManifest: ReactServerManifest;
-
-  /** (insert teaser trailer) */
-  declare const actionManifest: never;
-}
-
-declare module "bun:bake/client" {
   /**
-   * Entries in this manifest can be loaded by using dynamic `await import()` or
-   * `require`. The bundler currently ensures that all modules are ready.
+   * Entries in this manifest map from client-side files to their respective SSR
+   * bundles. They can be loaded by `await import()` or `require()`.
    */
   declare const clientManifest: ReactClientManifest;
-}
 
-declare interface ReactClientManifest {
-  [id: string]: {
-    [name: string]: {
-      /** Valid specifier to import */
-      specifier: string;
-      /** Export name */
+  /** (insert teaser trailer) */
+  declare const actionManifest: never;
+
+  declare interface ReactServerManifest {
+    /**
+     * Concatenation of the component file ID and the instance id with '#'
+     * Example: 'components/Navbar.tsx#default' (dev) or 'l2#a' (prod/minified)
+     *
+     * The component file ID and the instance id are both passed to `registerClientReference`
+     */
+    [combinedComponentId: string]: {
+      /**
+       * The `id` in ReactClientManifest.
+       * Correlates but is not required to be the filename
+       */
+      id: string;
+      /**
+       * The `name` in ReactServerManifest
+       * Correlates but is not required to be the export name
+       */
       name: string;
+      /** Currently not implemented; always an empty array */
+      chunks: [];
     };
-  };
+  }
+
+  declare interface ReactClientManifest {
+    /** ReactServerManifest[...].id */
+    [id: string]: {
+      /** ReactServerManifest[...].name */
+      [name: string]: {
+        /** Valid specifier to import */
+        specifier: string;
+        /** Export name */
+        name: string;
+      };
+    };
+  }
 }
 
-declare interface ReactServerManifest {
+declare module "bun:bake/client" {
   /**
-   * Concatenation of the component file ID and the instance id with '#'
-   * Example: 'components/Navbar.tsx#default' (dev) or 'l2#a' (prod/minified)
-   *
-   * The component file ID and the instance id are both passed to `registerClientReference`
+   * Due to the current implementation of the Dev Server, it must be informed of
+   * client-side routing so it can load client components. This is not necessary
+   * in production, and calling this in that situation will fail to compile.
    */
-  [combinedComponentId: string]: {
-    /**
-     * The `id` in ReactClientManifest.
-     * Correlates but is not required to be the filename
-     */
-    id: string;
-    /**
-     * The `name` in ReactServerManifest
-     * Correlates but is not required to be the export name
-     */
-    name: string;
-    /** Currently not implemented; always an empty array */
-    chunks: [];
-  };
+  declare function bundleRouteForDevelopment(href: string, options?: { signal?: AbortSignal }): Promise<void>;
 }
diff --git a/src/bake/bake.private.d.ts b/src/bake/bake.private.d.ts
index c7c740ef395009..9497ab63ecc4ac 100644
--- a/src/bake/bake.private.d.ts
+++ b/src/bake/bake.private.d.ts
@@ -31,37 +31,79 @@ declare const config: Config;
 
 /**
  * The runtime is bundled for server and client, which influences
- * how hmr connection should be established, as well if there is
+ * how HMR connection should be established, as well if there is
  * a window to visually display errors with.
  */
 declare const side: "client" | "server";
 
-/*
- * This variable becomes the default export. Kit uses this
- * interface as opposed to a WebSocket connection.
- */
-declare var server_exports: {
-  handleRequest: (req: Request, routeModuleId: Id, clientEntryUrl: string, styles: string[]) => any;
-  registerUpdate: (
-    modules: any,
-    componentManifestAdd: null | string[],
-    componentManifestDelete: null | string[],
-  ) => void;
-};
-
 /*
  * If you are running a debug build of Bun. These debug builds should provide
- * helpful information to someone working on the bundler itself.
+ * helpful information to someone working on the bundler itself. Assertions
+ * aimed for the end user should always be enabled.
  */
 declare const IS_BUN_DEVELOPMENT: any;
 
-// shims for experimental react types
-declare module "react" {
-  export function use<T>(promise: Promise<T>): T;
-}
+declare var __bun_f: any;
+
+// The following interfaces have been transcribed manually.
+
 declare module "react-server-dom-webpack/client.browser" {
-  export function createFromReadableStream<T = any>(readable: ReadableStream, manifest?: any): Promise<T>;
+  export function createFromReadableStream<T = any>(readable: ReadableStream<Uint8Array>): Promise<T>;
+}
+
+declare module "react-server-dom-webpack/client.node.unbundled.js" {
+  import type { ReactClientManifest } from "bun:bake/server";
+  import type { Readable } from "node:stream";
+  export interface Manifest {
+    moduleMap: ReactClientManifest;
+    moduleLoading?: ModuleLoading;
+  }
+  export interface ModuleLoading {
+    prefix: string;
+    crossOrigin?: string;
+  }
+  export interface Options {
+    encodeFormAction?: any;
+    findSourceMapURL?: any;
+    environmentName?: string;
+  }
+  export function createFromNodeStream<T = any>(readable: Readable, manifest?: Manifest): Promise<T>;
 }
-declare module "react-server-dom-webpack/server.browser" {
-  export function renderToReadableStream<T = any>(element: JSX.Element, manifest: any): ReadableStream;
+
+declare module "react-server-dom-webpack/server.node.unbundled.js" {
+  import type { ReactServerManifest } from "bun:bake/server";
+  import type { ReactElement, ReactElement } from "react";
+  import type { Writable } from "node:stream";
+
+  export interface PipeableStream<T> {
+    /** Returns the input, which should match the Node.js writable interface */
+    pipe: <T>(destination: T) => T;
+    abort: () => void;
+  }
+
+  export function renderToPipeableStream<T = any>(
+    model: ReactElement,
+    webpackMap: ReactServerManifest,
+    options?: RenderToPipeableStreamOptions,
+  ): PipeableStream<T>;
+
+  export interface RenderToPipeableStreamOptions {
+    onError?: Function;
+    identifierPrefix?: string;
+    onPostpone?: Function;
+    temporaryReferences?: any;
+    environmentName?: string;
+    filterStackFrame?: Function;
+  }
+}
+
+declare module "react-dom/server.node" {
+  import type { PipeableStream } from "react-server-dom-webpack/server.node.unbundled.js";
+  import type { ReactElement } from "react";
+
+  export type RenderToPipeableStreamOptions = any;
+  export function renderToPipeableStream(
+    model: ReactElement,
+    options: RenderToPipeableStreamOptions,
+  ): PipeableStream<Uint8Array>;
 }
diff --git a/src/bake/bake.zig b/src/bake/bake.zig
index 50f65b087cb2e7..7045bce7722ddd 100644
--- a/src/bake/bake.zig
+++ b/src/bake/bake.zig
@@ -3,88 +3,194 @@
 //! server, server components, and other integrations. Instead of taking the
 //! role as a framework, Bake is tool for frameworks to build on top of.
 
-/// Zig version of TS definition 'Bake.Options' in 'bake.d.ts'
+pub const production = @import("./production.zig");
+pub const DevServer = @import("./DevServer.zig");
+pub const FrameworkRouter = @import("./FrameworkRouter.zig");
+
+/// export default { app: ... };
+pub const api_name = "app";
+
+/// Zig version of the TS definition 'Bake.Options' in 'bake.d.ts'
 pub const UserOptions = struct {
+    arena: std.heap.ArenaAllocator.State,
+    allocations: StringRefList,
+
+    root: []const u8,
     framework: Framework,
+    bundler_options: SplitBundlerOptions,
+
+    pub fn deinit(options: *UserOptions) void {
+        options.arena.promote(bun.default_allocator).deinit();
+        options.allocations.free();
+    }
+
+    pub fn fromJS(config: JSValue, global: *JSC.JSGlobalObject) !UserOptions {
+        if (!config.isObject()) {
+            return global.throwInvalidArguments2("'" ++ api_name ++ "' is not an object", .{});
+        }
+        var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+        errdefer arena.deinit();
+        const alloc = arena.allocator();
+
+        var allocations = StringRefList.empty;
+        errdefer allocations.free();
+        var bundler_options: SplitBundlerOptions = .{};
+
+        const framework = try Framework.fromJS(
+            try config.get2(global, "framework") orelse {
+                return global.throwInvalidArguments2("'" ++ api_name ++ "' is missing 'framework'", .{});
+            },
+            global,
+            &allocations,
+            &bundler_options,
+            alloc,
+        );
+
+        const root = if (try config.getOptional(global, "root", ZigString.Slice)) |slice|
+            allocations.track(slice)
+        else
+            bun.getcwdAlloc(alloc) catch |err| switch (err) {
+                error.OutOfMemory => {
+                    global.throwOutOfMemory();
+                    return error.JSError;
+                },
+                else => {
+                    global.throwError(err, "while querying current working directory");
+                    return error.JSError;
+                },
+            };
+
+        return .{
+            .arena = arena.state,
+            .allocations = allocations,
+            .root = root,
+            .framework = framework,
+            .bundler_options = bundler_options,
+        };
+    }
+};
+
+/// Each string stores its allocator since some may hold reference counts to JSC
+const StringRefList = struct {
+    strings: std.ArrayListUnmanaged(ZigString.Slice),
+
+    pub fn track(al: *StringRefList, str: ZigString.Slice) []const u8 {
+        al.strings.append(bun.default_allocator, str) catch bun.outOfMemory();
+        return str.slice();
+    }
+
+    pub fn free(al: *StringRefList) void {
+        for (al.strings.items) |item| item.deinit();
+        al.strings.clearAndFree(bun.default_allocator);
+    }
+
+    pub const empty: StringRefList = .{ .strings = .{} };
+};
+
+const SplitBundlerOptions = struct {
+    all: BuildConfigSubset = .{},
+    client: BuildConfigSubset = .{},
+    server: BuildConfigSubset = .{},
+    ssr: BuildConfigSubset = .{},
+};
+
+const BuildConfigSubset = struct {
+    loader: ?bun.Schema.Api.LoaderMap = null,
+    ignoreDCEAnnotations: ?bool = null,
+    conditions: bun.StringArrayHashMapUnmanaged(void) = .{},
+    drop: bun.StringArrayHashMapUnmanaged(void) = .{},
+    // TODO: plugins
 };
 
 /// Temporary function to invoke dev server via JavaScript. Will be
 /// replaced with a user-facing API. Refs the event loop forever.
-pub fn jsWipDevServer(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
-    if (!bun.FeatureFlags.bake) return .undefined;
+pub fn jsWipDevServer(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
+    _ = global;
+    _ = callframe;
 
-    BakeInitProcessIdentifier();
+    if (!bun.FeatureFlags.bake) return .undefined;
 
-    bun.Output.warn(
-        \\Be advised that Bun Bake is highly experimental, and its API
-        \\will have breaking changes. Join the <magenta>#bake<r> Discord
-        \\channel to help us find bugs: <blue>https://bun.sh/discord<r>
+    bun.Output.errGeneric(
+        \\This api has moved to the `app` property of the default export.
         \\
+        \\  export default {{
+        \\    port: 3000,
+        \\    app: {{
+        \\      framework: 'react'
+        \\    }},
+        \\  }};
         \\
-    , .{});
-    bun.Output.flush();
-
-    const options = bakeOptionsFromJs(global, callframe.argument(0)) catch {
-        if (!global.hasException())
-            global.throwInvalidArguments("invalid arguments", .{});
-        return .zero;
-    };
-
-    // TODO: this should inherit the current VM, running on the main thread.
-    const t = std.Thread.spawn(.{}, wipDevServer, .{options}) catch @panic("Failed to start");
-    t.detach();
-
-    {
-        var futex = std.atomic.Value(u32).init(0);
-        while (true) std.Thread.Futex.wait(&futex, 0);
-    }
+    ,
+        .{},
+    );
+    return .undefined;
 }
 
-extern fn BakeInitProcessIdentifier() void;
-
 /// A "Framework" in our eyes is simply set of bundler options that a framework
 /// author would set in order to integrate the framework with the application.
+/// Since many fields have default values which may point to static memory, this
+/// structure is always arena-allocated, usually owned by the arena in `UserOptions`
 ///
 /// Full documentation on these fields is located in the TypeScript definitions.
 pub const Framework = struct {
-    entry_client: []const u8,
-    entry_server: []const u8,
-
+    file_system_router_types: []FileSystemRouterType,
+    // static_routers: [][]const u8,
     server_components: ?ServerComponents = null,
     react_fast_refresh: ?ReactFastRefresh = null,
-
     built_in_modules: bun.StringArrayHashMapUnmanaged(BuiltInModule) = .{},
 
     /// Bun provides built-in support for using React as a framework.
     /// Depends on externally provided React
     ///
     /// $ bun i react@experimental react-dom@experimental react-server-dom-webpack@experimental react-refresh@experimental
-    pub fn react() Framework {
+    pub fn react(arena: std.mem.Allocator) !Framework {
         return .{
             .server_components = .{
                 .separate_ssr_graph = true,
-                .server_runtime_import = "react-server-dom-webpack/server",
-                // .client_runtime_import = "react-server-dom-webpack/client",
+                .server_runtime_import = "react-server-dom-bun/server",
             },
             .react_fast_refresh = .{},
-            .entry_client = "bun-framework-rsc/client.tsx",
-            .entry_server = "bun-framework-rsc/server.tsx",
-            .built_in_modules = bun.StringArrayHashMapUnmanaged(BuiltInModule).init(bun.default_allocator, &.{
-                "bun-framework-rsc/client.tsx",
-                "bun-framework-rsc/server.tsx",
-                "bun-framework-rsc/ssr.tsx",
+            .file_system_router_types = try arena.dupe(FileSystemRouterType, &.{
+                .{
+                    .root = "pages",
+                    .prefix = "/",
+                    .entry_client = "bun-framework-react/client.tsx",
+                    .entry_server = "bun-framework-react/server.tsx",
+                    .ignore_underscores = true,
+                    .ignore_dirs = &.{ "node_modules", ".git" },
+                    .extensions = &.{ ".tsx", ".jsx" },
+                    .style = .@"nextjs-pages-ui",
+                },
+            }),
+            // .static_routers = try arena.dupe([]const u8, &.{"public"}),
+            .built_in_modules = bun.StringArrayHashMapUnmanaged(BuiltInModule).init(arena, &.{
+                "bun-framework-react/client.tsx",
+                "bun-framework-react/server.tsx",
+                "bun-framework-react/ssr.tsx",
             }, if (Environment.codegen_embed) &.{
-                .{ .code = @embedFile("./bun-framework-rsc/client.tsx") },
-                .{ .code = @embedFile("./bun-framework-rsc/server.tsx") },
-                .{ .code = @embedFile("./bun-framework-rsc/ssr.tsx") },
+                .{ .code = @embedFile("./bun-framework-react/client.tsx") },
+                .{ .code = @embedFile("./bun-framework-react/server.tsx") },
+                .{ .code = @embedFile("./bun-framework-react/ssr.tsx") },
             } else &.{
-                .{ .code = bun.runtimeEmbedFile(.src, "bake/bun-framework-rsc/client.tsx") },
-                .{ .code = bun.runtimeEmbedFile(.src, "bake/bun-framework-rsc/server.tsx") },
-                .{ .code = bun.runtimeEmbedFile(.src, "bake/bun-framework-rsc/ssr.tsx") },
+                // Cannot use .import because resolution must happen from the user's POV
+                .{ .code = bun.runtimeEmbedFile(.src, "bake/bun-framework-react/client.tsx") },
+                .{ .code = bun.runtimeEmbedFile(.src, "bake/bun-framework-react/server.tsx") },
+                .{ .code = bun.runtimeEmbedFile(.src, "bake/bun-framework-react/ssr.tsx") },
             }) catch bun.outOfMemory(),
         };
     }
 
+    const FileSystemRouterType = struct {
+        root: []const u8,
+        prefix: []const u8,
+        entry_server: []const u8,
+        entry_client: ?[]const u8,
+        ignore_underscores: bool,
+        ignore_dirs: []const []const u8,
+        extensions: []const []const u8,
+        style: FrameworkRouter.Style,
+    };
+
     const BuiltInModule = union(enum) {
         import: []const u8,
         code: []const u8,
@@ -111,9 +217,6 @@ pub const Framework = struct {
         var clone = f;
         var had_errors: bool = false;
 
-        f.resolveHelper(client, &clone.entry_client, &had_errors, "client entrypoint");
-        f.resolveHelper(server, &clone.entry_server, &had_errors, "server entrypoint");
-
         if (clone.react_fast_refresh) |*react_fast_refresh| {
             f.resolveHelper(client, &react_fast_refresh.import_source, &had_errors, "react refresh runtime");
         }
@@ -123,6 +226,13 @@ pub const Framework = struct {
             // f.resolveHelper(client, &sc.client_runtime_import, &had_errors);
         }
 
+        for (clone.file_system_router_types) |*fsr| {
+            // TODO: unonwned memory
+            fsr.root = bun.path.joinAbs(server.fs.top_level_dir, .auto, fsr.root);
+            if (fsr.entry_client) |*entry_client| f.resolveHelper(client, entry_client, &had_errors, "client side entrypoint");
+            f.resolveHelper(client, &fsr.entry_server, &had_errors, "server side entrypoint");
+        }
+
         if (had_errors) return error.ModuleNotFound;
 
         return clone;
@@ -142,141 +252,221 @@ pub const Framework = struct {
             had_errors.* = true;
             return;
         };
-        path.* = result.path().?.text; // TODO: what is the lifetime of this string
+        path.* = result.path().?.text;
     }
 
-    // TODO: This function always leaks memory.
-    // `Framework` has no way to specify what is allocated, nor should it.
-    fn fromJS(opts: JSValue, global: *JSC.JSGlobalObject) !Framework {
+    fn fromJS(
+        opts: JSValue,
+        global: *JSC.JSGlobalObject,
+        refs: *StringRefList,
+        bundler_options: *SplitBundlerOptions,
+        arena: Allocator,
+    ) !Framework {
+        _ = bundler_options; // autofix
         if (opts.isString()) {
-            const str = opts.toBunString(global);
+            const str = try opts.toBunString2(global);
             defer str.deref();
+
+            // Deprecated
             if (str.eqlComptime("react-server-components")) {
-                return Framework.react();
+                bun.Output.warn("deprecation notice: 'react-server-components' will be renamed to 'react'", .{});
+                return Framework.react(arena);
             }
+
             if (str.eqlComptime("react")) {
-                return Framework.react();
+                return Framework.react(arena);
             }
         }
 
         if (!opts.isObject()) {
-            global.throwInvalidArguments("Framework must be an object", .{});
-            return error.JSError;
+            return global.throwInvalidArguments2("Framework must be an object", .{});
         }
-        return .{
-            .entry_server = brk: {
-                const prop: JSValue = opts.get(global, "serverEntryPoint") orelse {
-                    if (!global.hasException())
-                        global.throwInvalidArguments("Missing 'framework.serverEntryPoint'", .{});
-                    return error.JSError;
-                };
-                const str = prop.toBunString(global);
-                defer str.deref();
 
-                if (global.hasException())
-                    return error.JSError;
+        if (try opts.get2(global, "serverEntryPoint") != null) {
+            bun.Output.warn("deprecation notice: 'framework.serverEntryPoint' has been replaced with 'fileSystemRouterTypes[n].serverEntryPoint'", .{});
+        }
+        if (try opts.get2(global, "clientEntryPoint") != null) {
+            bun.Output.warn("deprecation notice: 'framework.clientEntryPoint' has been replaced with 'fileSystemRouterTypes[n].clientEntryPoint'", .{});
+        }
 
-                // Leak
-                break :brk str.toUTF8(bun.default_allocator).slice();
-            },
-            .entry_client = brk: {
-                const prop: JSValue = opts.get(global, "clientEntryPoint") orelse {
-                    if (!global.hasException())
-                        global.throwInvalidArguments("Missing 'framework.clientEntryPoint'", .{});
-                    return error.JSError;
-                };
-                const str = prop.toBunString(global);
-                defer str.deref();
+        const react_fast_refresh: ?ReactFastRefresh = brk: {
+            const rfr: JSValue = try opts.get2(global, "reactFastRefresh") orelse
+                break :brk null;
 
-                if (global.hasException())
-                    return error.JSError;
+            if (rfr == .true) break :brk .{};
+            if (rfr == .false or rfr == .null or rfr == .undefined) break :brk null;
 
-                // Leak
-                break :brk str.toUTF8(bun.default_allocator).slice();
-            },
-            .react_fast_refresh = brk: {
-                const rfr: JSValue = opts.get(global, "reactFastRefresh") orelse {
-                    if (global.hasException())
-                        return error.JSError;
-                    break :brk null;
-                };
-                if (rfr == .true) break :brk .{};
-                if (rfr == .false or rfr == .null or rfr == .undefined) break :brk null;
-                if (!rfr.isObject()) {
-                    global.throwInvalidArguments("'framework.reactFastRefresh' must be an object or 'true'", .{});
-                    return error.JSError;
+            if (!rfr.isObject()) {
+                return global.throwInvalidArguments2("'framework.reactFastRefresh' must be an object or 'true'", .{});
+            }
+
+            const prop = rfr.get(global, "importSource") orelse {
+                return global.throwInvalidArguments2("'framework.reactFastRefresh' is missing 'importSource'", .{});
+            };
+
+            const str = try prop.toBunString2(global);
+            defer str.deref();
+
+            break :brk .{
+                .import_source = refs.track(str.toUTF8(arena)),
+            };
+        };
+        const server_components: ?ServerComponents = sc: {
+            const sc: JSValue = try opts.get2(global, "serverComponents") orelse
+                break :sc null;
+            if (sc == .false or sc == .null or sc == .undefined) break :sc null;
+
+            if (!sc.isObject()) {
+                return global.throwInvalidArguments2("'framework.serverComponents' must be an object or 'undefined'", .{});
+            }
+
+            break :sc .{
+                .separate_ssr_graph = brk: {
+                    // Intentionally not using a truthiness check
+                    const prop = try sc.getOptional(global, "separateSSRGraph", JSValue) orelse {
+                        return global.throwInvalidArguments2("Missing 'framework.serverComponents.separateSSRGraph'", .{});
+                    };
+                    if (prop == .true) break :brk true;
+                    if (prop == .false) break :brk false;
+                    return global.throwInvalidArguments2("'framework.serverComponents.separateSSRGraph' must be a boolean", .{});
+                },
+                .server_runtime_import = refs.track(
+                    try sc.getOptional(global, "serverRuntimeImportSource", ZigString.Slice) orelse {
+                        return global.throwInvalidArguments2("Missing 'framework.serverComponents.serverRuntimeImportSource'", .{});
+                    },
+                ),
+                .server_register_client_reference = refs.track(
+                    try sc.getOptional(global, "serverRegisterClientReferenceExport", ZigString.Slice) orelse {
+                        return global.throwInvalidArguments2("Missing 'framework.serverComponents.serverRegisterClientReferenceExport'", .{});
+                    },
+                ),
+            };
+        };
+        const built_in_modules: bun.StringArrayHashMapUnmanaged(BuiltInModule) = built_in_modules: {
+            const array = try opts.getArray(global, "builtInModules") orelse
+                break :built_in_modules .{};
+
+            const len = array.getLength(global);
+            var files: bun.StringArrayHashMapUnmanaged(BuiltInModule) = .{};
+            try files.ensureTotalCapacity(arena, len);
+
+            var it = array.arrayIterator(global);
+            var i: usize = 0;
+            while (it.next()) |file| : (i += 1) {
+                if (!file.isObject()) {
+                    return global.throwInvalidArguments2("'builtInModules[{d}]' is not an object", .{i});
                 }
 
-                const prop = rfr.get(global, "importSource") orelse {
-                    global.throwInvalidArguments("'framework.reactFastRefresh' is missing 'importSource'", .{});
-                    return error.JSError;
+                const path = try getOptionalString(file, global, "import", refs, arena) orelse {
+                    return global.throwInvalidArguments2("'builtInModules[{d}]' is missing 'import'", .{i});
                 };
 
-                const str = prop.toBunString(global);
-                defer str.deref();
+                const value: BuiltInModule = if (try getOptionalString(file, global, "path", refs, arena)) |str|
+                    .{ .import = str }
+                else if (try getOptionalString(file, global, "code", refs, arena)) |str|
+                    .{ .code = str }
+                else
+                    return global.throwInvalidArguments2("'builtInModules[{d}]' needs either 'path' or 'code'", .{i});
 
-                if (global.hasException())
-                    return error.JSError;
+                files.putAssumeCapacity(path, value);
+            }
+
+            break :built_in_modules files;
+        };
+        const file_system_router_types: []FileSystemRouterType = brk: {
+            const array: JSValue = try opts.getArray(global, "fileSystemRouterTypes") orelse {
+                return global.throwInvalidArguments2("Missing 'framework.fileSystemRouterTypes'", .{});
+            };
+            const len = array.getLength(global);
+            if (len > 256) {
+                return global.throwInvalidArguments2("Framework can only define up to 256 file-system router types", .{});
+            }
+            const file_system_router_types = try arena.alloc(FileSystemRouterType, len);
 
-                // Leak
-                break :brk .{
-                    .import_source = str.toUTF8(bun.default_allocator).slice(),
+            var it = array.arrayIterator(global);
+            var i: usize = 0;
+            while (it.next()) |fsr_opts| : (i += 1) {
+                const root = try getOptionalString(fsr_opts, global, "root", refs, arena) orelse {
+                    return global.throwInvalidArguments2("'fileSystemRouterTypes[{d}]' is missing 'root'", .{i});
                 };
-            },
-            .server_components = sc: {
-                const sc: JSValue = opts.get(global, "serverComponents") orelse {
-                    if (global.hasException())
-                        return error.JSError;
-                    break :sc null;
+                const server_entry_point = try getOptionalString(fsr_opts, global, "serverEntryPoint", refs, arena) orelse {
+                    return global.throwInvalidArguments2("'fileSystemRouterTypes[{d}]' is missing 'serverEntryPoint'", .{i});
                 };
-                if (sc == .null or sc == .undefined) break :sc null;
-
-                break :sc .{
-                    // .client_runtime_import = "",
-                    .separate_ssr_graph = brk: {
-                        const prop: JSValue = sc.get(global, "separateSSRGraph") orelse {
-                            if (!global.hasException())
-                                global.throwInvalidArguments("Missing 'framework.serverComponents.separateSSRGraph'", .{});
-                            return error.JSError;
-                        };
-                        if (prop == .true) break :brk true;
-                        if (prop == .false) break :brk false;
-                        global.throwInvalidArguments("'framework.serverComponents.separateSSRGraph' must be a boolean", .{});
-                        return error.JSError;
-                    },
-                    .server_runtime_import = brk: {
-                        const prop: JSValue = sc.get(global, "serverRuntimeImportSource") orelse {
-                            if (!global.hasException())
-                                global.throwInvalidArguments("Missing 'framework.serverComponents.serverRuntimeImportSource'", .{});
-                            return error.JSError;
-                        };
-                        const str = prop.toBunString(global);
-                        defer str.deref();
-
-                        if (global.hasException())
-                            return error.JSError;
-
-                        // Leak
-                        break :brk str.toUTF8(bun.default_allocator).slice();
-                    },
-                    .server_register_client_reference = brk: {
-                        const prop: JSValue = sc.get(global, "serverRegisterClientReferenceExport") orelse {
-                            if (!global.hasException())
-                                global.throwInvalidArguments("Missing 'framework.serverComponents.serverRegisterClientReferenceExport'", .{});
-                            return error.JSError;
-                        };
-                        const str = prop.toBunString(global);
-                        defer str.deref();
-
-                        if (global.hasException())
-                            return error.JSError;
-
-                        // Leak
-                        break :brk str.toUTF8(bun.default_allocator).slice();
-                    },
+                const client_entry_point = try getOptionalString(fsr_opts, global, "clientEntryPoint", refs, arena);
+                const prefix = try getOptionalString(fsr_opts, global, "prefix", refs, arena) orelse "/";
+                const ignore_underscores = try fsr_opts.getBooleanStrict(global, "ignoreUnderscores") orelse false;
+
+                const style = try validators.validateStringEnum(
+                    FrameworkRouter.Style,
+                    global,
+                    try opts.getOptional(global, "style", JSValue) orelse .undefined,
+                    "style",
+                    .{},
+                );
+
+                const extensions: []const []const u8 = if (try fsr_opts.get2(global, "extensions")) |exts_js| exts: {
+                    if (exts_js.isString()) {
+                        const str = try exts_js.toSlice2(global, arena);
+                        defer str.deinit();
+                        if (bun.strings.eqlComptime(str.slice(), "*")) {
+                            break :exts &.{};
+                        }
+                    } else if (exts_js.isArray()) {
+                        var it_2 = array.arrayIterator(global);
+                        var i_2: usize = 0;
+                        const extensions = try arena.alloc([]const u8, len);
+                        while (it_2.next()) |array_item| : (i_2 += 1) {
+                            // TODO: remove/add the prefix `.`, throw error if specifying '*' as an array item instead of as root
+                            extensions[i_2] = refs.track(try array_item.toSlice2(global, arena));
+                        }
+                        break :exts extensions;
+                    }
+
+                    return global.throwInvalidArguments2("'extensions' must be an array of strings or \"*\" for all extensions", .{});
+                } else &.{ ".jsx", ".tsx", ".js", ".ts", ".cjs", ".cts", ".mjs", ".mts" };
+
+                const ignore_dirs: []const []const u8 = if (try fsr_opts.get2(global, "ignoreDirs")) |exts_js| exts: {
+                    if (exts_js.isArray()) {
+                        var it_2 = array.arrayIterator(global);
+                        var i_2: usize = 0;
+                        const dirs = try arena.alloc([]const u8, len);
+                        while (it_2.next()) |array_item| : (i_2 += 1) {
+                            dirs[i_2] = refs.track(try array_item.toSlice2(global, arena));
+                        }
+                        break :exts dirs;
+                    }
+
+                    return global.throwInvalidArguments2("'ignoreDirs' must be an array of strings or \"*\" for all extensions", .{});
+                } else &.{ ".git", "node_modules" };
+
+                file_system_router_types[i] = .{
+                    .root = root,
+                    .prefix = prefix,
+                    .style = style,
+                    .entry_server = server_entry_point,
+                    .entry_client = client_entry_point,
+                    .ignore_underscores = ignore_underscores,
+                    .extensions = extensions,
+                    .ignore_dirs = ignore_dirs,
                 };
-            },
+            }
+
+            break :brk file_system_router_types;
         };
+
+        const framework: Framework = .{
+            .file_system_router_types = file_system_router_types,
+            .react_fast_refresh = react_fast_refresh,
+            .server_components = server_components,
+            .built_in_modules = built_in_modules,
+        };
+
+        if (try opts.getOptional(global, "bundlerOptions", JSValue)) |js_options| {
+            _ = js_options; // autofix
+            // try SplitBundlerOptions.parseInto(global, js_options, bundler_options, .root);
+        }
+
+        return framework;
     }
 
     pub fn initBundler(
@@ -306,11 +496,11 @@ pub const Framework = struct {
         out.options.log = log;
         out.options.output_format = switch (mode) {
             .development => .internal_bake_dev,
-            .production => .esm,
+            .production_dynamic, .production_static => .esm,
         };
         out.options.out_extensions = bun.StringHashMap([]const u8).init(out.allocator);
         out.options.hot_module_reloading = mode == .development;
-        out.options.code_splitting = mode == .production;
+        out.options.code_splitting = mode != .development;
 
         // force disable filesystem output, even though bundle_v2
         // is special cased to return before that code is reached.
@@ -325,12 +515,12 @@ pub const Framework = struct {
             try out.options.conditions.appendSlice(&.{"react-server"});
         }
 
-        out.options.production = mode == .production;
+        out.options.production = mode != .development;
 
-        out.options.tree_shaking = mode == .production;
+        out.options.tree_shaking = mode != .development;
         out.options.minify_syntax = true; // required for DCE
-        // out.options.minify_identifiers = mode == .production;
-        // out.options.minify_whitespace = mode == .production;
+        // out.options.minify_identifiers = mode != .development;
+        // out.options.minify_whitespace = mode != .development;
 
         out.options.experimental_css = true;
         out.options.css_chunking = true;
@@ -347,7 +537,7 @@ pub const Framework = struct {
             .server, .ssr => .server,
         });
 
-        if (mode == .production) {
+        if (mode != .development) {
             out.options.entry_naming = "[name]-[hash].[ext]";
             out.options.chunk_naming = "chunk-[name]-[hash].[ext]";
         }
@@ -356,78 +546,48 @@ pub const Framework = struct {
     }
 };
 
-// TODO: this function leaks memory and bad error handling, but that is OK since
-pub fn bakeOptionsFromJs(global: *JSC.JSGlobalObject, options: JSValue) !DevServer.Options {
-    if (!options.isObject()) return error.Invalid;
-    const routes_js = try options.getArray(global, "routes") orelse return error.Invalid;
-
-    const len = routes_js.getLength(global);
-    const routes = try bun.default_allocator.alloc(DevServer.Route, len);
-
-    var it = routes_js.arrayIterator(global);
-    var i: usize = 0;
-    while (it.next()) |route| : (i += 1) {
-        if (!route.isObject()) return error.Invalid;
-
-        const pattern_js = route.get(global, "pattern") orelse return error.Invalid;
-        if (!pattern_js.isString()) return error.Invalid;
-        const entry_point_js = route.get(global, "entrypoint") orelse return error.Invalid;
-        if (!entry_point_js.isString()) return error.Invalid;
-
-        const pattern = pattern_js.toBunString(global).toUTF8(bun.default_allocator);
-        defer pattern.deinit();
-        // TODO: this dupe is stupid
-        const pattern_z = try bun.default_allocator.dupeZ(u8, pattern.slice());
-        const entry_point = entry_point_js.toBunString(global).toUTF8(bun.default_allocator).slice(); // leak
-
-        routes[i] = .{
-            .pattern = pattern_z,
-            .entry_point = entry_point,
-        };
-    }
-
-    const framework_js = options.get(global, "framework") orelse {
-        return error.Invalid;
-    };
-    const framework = try Framework.fromJS(framework_js, global);
-    return .{
-        .cwd = bun.getcwdAlloc(bun.default_allocator) catch bun.outOfMemory(),
-        .routes = routes,
-        .framework = framework,
-    };
+fn getOptionalString(
+    target: JSValue,
+    global: *JSC.JSGlobalObject,
+    property: []const u8,
+    allocations: *StringRefList,
+    arena: Allocator,
+) !?[]const u8 {
+    const value = try target.get2(global, property) orelse
+        return null;
+    if (value == .undefined or value == .null)
+        return null;
+    const str = try value.toBunString2(global);
+    return allocations.track(str.toUTF8(arena));
 }
 
 export fn Bun__getTemporaryDevServer(global: *JSC.JSGlobalObject) JSValue {
     if (!bun.FeatureFlags.bake) return .undefined;
-    return JSC.JSFunction.create(global, "wipDevServer", bun.JSC.toJSHostFunction(jsWipDevServer), 0, .{});
-}
-
-pub fn wipDevServer(options: DevServer.Options) noreturn {
-    bun.Output.Source.configureNamedThread("Dev Server");
-
-    const dev = DevServer.init(options) catch |err| switch (err) {
-        error.FrameworkInitialization => bun.Global.exit(1),
-        else => {
-            bun.handleErrorReturnTrace(err, @errorReturnTrace());
-            bun.Output.panic("Failed to init DevServer: {}", .{err});
-        },
-    };
-    dev.runLoopForever();
+    return JSC.JSFunction.create(global, "wipDevServer", jsWipDevServer, 0, .{});
 }
 
-pub fn getHmrRuntime(mode: Side) []const u8 {
+pub inline fn getHmrRuntime(side: Side) [:0]const u8 {
     return if (Environment.codegen_embed)
-        switch (mode) {
+        switch (side) {
             .client => @embedFile("bake-codegen/bake.client.js"),
             .server => @embedFile("bake-codegen/bake.server.js"),
         }
-    else switch (mode) {
-        inline else => |m| bun.runtimeEmbedFile(.codegen_eager, "bake." ++ @tagName(m) ++ ".js"),
+    else switch (side) {
+        .client => bun.runtimeEmbedFile(.codegen_eager, "bake.client.js"),
+        // may not be live-reloaded
+        .server => bun.runtimeEmbedFile(.codegen, "bake.server.js"),
     };
 }
 
-pub const Mode = enum { production, development };
-pub const Side = enum { client, server };
+pub const Mode = enum {
+    development,
+    production_dynamic,
+    production_static,
+};
+pub const Side = enum(u1) {
+    client,
+    server,
+};
 pub const Graph = enum(u2) {
     client,
     server,
@@ -444,7 +604,9 @@ pub fn addImportMetaDefines(
     const Define = bun.options.Define;
 
     // The following are from Vite: https://vitejs.dev/guide/env-and-mode
-    // TODO: MODE, BASE_URL
+    // Note that it is not currently possible to have mixed
+    // modes (production + hmr dev server)
+    // TODO: BASE_URL
     try define.insert(
         allocator,
         "import.meta.env.DEV",
@@ -453,13 +615,28 @@ pub fn addImportMetaDefines(
     try define.insert(
         allocator,
         "import.meta.env.PROD",
-        Define.Data.initBoolean(mode == .production),
+        Define.Data.initBoolean(mode != .development),
+    );
+    try define.insert(
+        allocator,
+        "import.meta.env.MODE",
+        Define.Data.initStaticString(switch (mode) {
+            .development => &.{ .data = "development" },
+            .production_dynamic, .production_static => &.{ .data = "production" },
+        }),
     );
     try define.insert(
         allocator,
         "import.meta.env.SSR",
         Define.Data.initBoolean(side == .server),
     );
+
+    // To indicate a static build, `STATIC` is set to true then.
+    try define.insert(
+        allocator,
+        "import.meta.env.STATIC",
+        Define.Data.initBoolean(mode == .production_static),
+    );
 }
 
 pub const server_virtual_source: bun.logger.Source = .{
@@ -474,13 +651,49 @@ pub const client_virtual_source: bun.logger.Source = .{
     .index = bun.JSAst.Index.bake_client_data,
 };
 
-pub const production = @import("./production.zig");
-pub const DevServer = @import("./DevServer.zig");
+/// Stack-allocated structure that is written to from end to start.
+/// Used as a staging area for building pattern strings.
+pub const PatternBuffer = struct {
+    bytes: bun.PathBuffer,
+    i: std.math.IntFittingRange(0, @sizeOf(bun.PathBuffer)),
+
+    pub const empty: PatternBuffer = .{
+        .bytes = undefined,
+        .i = @sizeOf(bun.PathBuffer),
+    };
+
+    pub fn prepend(pb: *PatternBuffer, chunk: []const u8) void {
+        bun.assert(pb.i >= chunk.len);
+        pb.i -= @intCast(chunk.len);
+        @memcpy(pb.slice()[0..chunk.len], chunk);
+    }
+
+    pub fn prependPart(pb: *PatternBuffer, part: FrameworkRouter.Part) void {
+        switch (part) {
+            .text => |text| {
+                pb.prepend(text);
+                pb.prepend("/");
+            },
+            .param, .catch_all, .catch_all_optional => |name| {
+                pb.prepend(name);
+                pb.prepend("/:");
+            },
+            .group => {},
+        }
+    }
+
+    pub fn slice(pb: *PatternBuffer) []u8 {
+        return pb.bytes[pb.i..];
+    }
+};
 
 const std = @import("std");
+const Allocator = std.mem.Allocator;
 
 const bun = @import("root").bun;
 const Environment = bun.Environment;
+const ZigString = bun.JSC.ZigString;
 
 const JSC = bun.JSC;
 const JSValue = JSC.JSValue;
+const validators = bun.JSC.Node.validators;
diff --git a/src/bake/bun-framework-react/client.tsx b/src/bake/bun-framework-react/client.tsx
new file mode 100644
index 00000000000000..c0dc76ddcc8e8c
--- /dev/null
+++ b/src/bake/bun-framework-react/client.tsx
@@ -0,0 +1,177 @@
+// This file contains the client-side logic for the built in React Server
+// Components integration. It is designed as a minimal base to build RSC
+// applications on, and to showcase what features that Bake offers.
+/// <reference lib="dom" />
+import * as React from "react";
+import { hydrateRoot } from "react-dom/client";
+import { createFromReadableStream } from "react-server-dom-bun/client.browser";
+import { bundleRouteForDevelopment } from "bun:bake/client";
+
+let encoder = new TextEncoder();
+let promise = createFromReadableStream(
+  new ReadableStream({
+    start(controller) {
+      let handleChunk = chunk =>
+        typeof chunk === "string" //
+          ? controller.enqueue(encoder.encode(chunk))
+          : controller.enqueue(chunk);
+
+      (self.__bun_f ||= []).forEach((__bun_f.push = handleChunk));
+
+      if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", () => {
+          controller.close();
+        });
+      } else {
+        controller.close();
+      }
+    },
+  }),
+);
+
+// This is a function component that uses the `use` hook, which unwraps a
+// promise.  The promise results in a component containing suspense boundaries.
+// This is the same logic that happens on the server, except there is also a
+// hook to update the promise when the client navigates.
+let setPage;
+const Root = () => {
+  setPage = React.useState(promise)[1];
+  return React.use(promise);
+};
+const root = hydrateRoot(document, <Root />, {
+  // handle `onUncaughtError` here
+});
+
+// Client side navigation is implemented by updating the app's `useState` with a
+// new RSC payload promise. An abort controller is used to cancel a previous
+// navigation. Callers of `goto` are expected to manage history state.
+let currentReloadCtrl: AbortController | null = null;
+async function goto(href: string) {
+  // TODO: this abort signal stuff doesnt work
+  // if (currentReloadCtrl) {
+  //   currentReloadCtrl.abort();
+  // }
+  // const signal = (currentReloadCtrl = new AbortController()).signal;
+
+  // Due to the current implementation of the Dev Server, it must be informed of
+  // client-side routing so it can load client components. This is not necessary
+  // in production, and calling this in that situation will fail to compile.
+  if (import.meta.env.DEV) {
+    await bundleRouteForDevelopment(href, {
+      // signal
+    });
+  }
+
+  let response;
+  try {
+    // When using static builds, it isn't possible for the server to reliably
+    // branch on the `Accept` header. Instead, a static build creates a `.rsc`
+    // file that can be fetched. `import.meta.env.STATIC` is inlined by Bake.
+    response = await fetch(
+      import.meta.env.STATIC //
+        ? `${href.replace(/\/(?:index)?$/, "")}/index.rsc`
+        : href,
+      {
+        headers: {
+          Accept: "text/x-component",
+        },
+        // signal: signal,
+      },
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${href}: ${response.status} ${response.statusText}`);
+    }
+  } catch (err) {
+    // Bail out to browser navigation if this fetch fails.
+    console.error(err);
+    location.href = href;
+    return;
+  }
+
+  // if (signal.aborted) return;
+
+  // TODO: error handling? abort handling?
+  const p = createFromReadableStream(response.body!);
+
+  // TODO: ensure CSS is ready
+  // Right now you can see a flash of unstyled content, since react does not
+  // wait for new link tags to load before they are injected.
+
+  // Use a react transition to update the page promise.
+  // TODO: How to get this show after 100ms, it hangs until all suspenses resolve
+  // React.startTransition(() => {
+  //   if (signal.aborted) return;
+  //   setPage((promise = p));
+  // });
+  setPage?.((promise = p));
+}
+
+// Instead of relying on a "<Link />" component, a global event listener on all
+// clicks can be used. Care must be taken to intercept only anchor elements that
+// did not have their default behavior prevented, non-left clicks, and more.
+//
+// This technique was inspired by SvelteKit which was inspired by https://github.com/visionmedia/page.js
+document.addEventListener("click", async (event, element = event.target as HTMLAnchorElement) => {
+  if (
+    event.button ||
+    event.which != 1 ||
+    event.metaKey ||
+    event.ctrlKey ||
+    event.shiftKey ||
+    event.altKey ||
+    event.defaultPrevented
+  )
+    return;
+
+  while (element && element !== document.body) {
+    // This handles shadow roots
+    if (element.nodeType === 11) element = (element as any).host;
+
+    // If the current tag is an anchor.
+    if (element.nodeName.toUpperCase() === "A" && element.hasAttribute("href")) {
+      let url;
+      try {
+        url = new URL(element instanceof SVGAElement ? element.href.baseVal : element.href, document.baseURI);
+      } catch {
+        // Bail out to browser logic
+        return;
+      }
+
+      let pathname = url.pathname;
+      if (pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+
+      // Ignore if the link is external
+      if (url.origin !== origin || (element.getAttribute("rel") || "").split(/\s+/).includes("external")) {
+        return;
+      }
+
+      // TODO: consider `target` attribute
+
+      // Take no action at all if the url is the same page.
+      // However if there is a hash, don't call preventDefault()
+      if (pathname === location.pathname && url.search === location.search) {
+        return url.hash || event.preventDefault();
+      }
+
+      const href = url.href;
+      history.pushState({}, "", href);
+      goto(href);
+
+      return event.preventDefault();
+    }
+
+    // Walk up the tree until an anchor or the body is found.
+    element = (element.assignedSlot ?? element.parentNode) as HTMLAnchorElement;
+  }
+});
+
+// Handle browser navigation events
+window.addEventListener("popstate", () => goto(location.href));
+
+// Frameworks can export a `onServerSideReload` function to hook into server-side
+// hot module reloading. This export is not used in production and tree-shaken.
+export async function onServerSideReload() {
+  await goto(location.href);
+}
diff --git a/src/bake/bun-framework-react/index.ts b/src/bake/bun-framework-react/index.ts
new file mode 100644
index 00000000000000..1a120fc8a667b5
--- /dev/null
+++ b/src/bake/bun-framework-react/index.ts
@@ -0,0 +1,40 @@
+// This file is unused by Bun itself, but rather is a tool for
+// contributors to hack on `bun-framework-react` without needing
+// to compile bun itself. If changes to this are made, please
+// update 'pub fn react' in 'bake.zig'
+import type { Bake } from "bun";
+
+export function react(): Bake.Framework {
+  return {
+    // When the files are embedded in the Bun binary,
+    // relative path resolution does not work.
+    builtInModules: [
+      { import: "bun-framework-react/client.tsx", path: require.resolve("./client.tsx") },
+      { import: "bun-framework-react/server.tsx", path: require.resolve("./server.tsx") },
+      { import: "bun-framework-react/ssr.tsx", path: require.resolve("./ssr.tsx") },
+    ],
+    fileSystemRouterTypes: [
+      {
+        root: "pages",
+        clientEntryPoint: "bun-framework-react/client.tsx",
+        serverEntryPoint: "bun-framework-react/server.tsx",
+        extensions: ["jsx", "tsx"],
+        style: "nextjs-pages-ui",
+      },
+    ],
+    staticRouters: ["public"],
+    reactFastRefresh: {
+      importSource: "react-refresh/runtime",
+    },
+    serverComponents: {
+      separateSSRGraph: true,
+      serverRegisterClientReferenceExport: "registerClientReference",
+      serverRuntimeImportSource: "react-server-dom-webpack/server",
+    },
+    bundlerOptions: {
+      ssr: {
+        conditions: ["react-server"],
+      },
+    },
+  };
+}
diff --git a/src/bake/bun-framework-react/server.tsx b/src/bake/bun-framework-react/server.tsx
new file mode 100644
index 00000000000000..f567a6aac23f7a
--- /dev/null
+++ b/src/bake/bun-framework-react/server.tsx
@@ -0,0 +1,117 @@
+import type { Bake } from "bun";
+import { renderToPipeableStream } from "react-server-dom-bun/server.node.unbundled.js";
+import { renderToHtml, renderToStaticHtml } from "bun-framework-react/ssr.tsx" with { bunBakeGraph: "ssr" };
+import { serverManifest } from "bun:bake/server";
+import { PassThrough } from "node:stream";
+
+function assertReactComponent(Component: any) {
+  if (typeof Component !== "function") {
+    console.log("Expected a React component", Component, typeof Component);
+    throw new Error("Expected a React component");
+  }
+}
+
+// This function converts the route information into a React component tree.
+function getPage(meta: Bake.RouteMetadata) {
+  const { styles } = meta;
+
+  const Page = meta.pageModule.default;
+  if (import.meta.env.DEV) assertReactComponent(Page);
+  let route = <Page />;
+  for (const layout of meta.layouts) {
+    const Layout = layout.default;
+    if (import.meta.env.DEV) assertReactComponent(Layout);
+    route = <Layout>{route}</Layout>;
+  }
+
+  return (
+    <html lang="en">
+      <head>
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <title>Bun + React Server Components</title>
+        {styles.map(url => (
+          <link key={url} rel="stylesheet" href={url} />
+        ))}
+      </head>
+      <body>{route}</body>
+    </html>
+  );
+}
+
+// `server.tsx` exports a function to be used for handling user routes. It takes
+// in the Request object, the route's module, and extra route metadata.
+export async function render(request: Request, meta: Bake.RouteMetadata): Promise<Response> {
+  // The framework generally has two rendering modes.
+  // - Standard browser navigation
+  // - Client-side navigation
+  //
+  // For React, this means we will always perform `renderToReadableStream` to
+  // generate the RSC payload, but only generate HTML for the former of these
+  // rendering modes. This is signaled by `client.tsx` via the `Accept` header.
+  const skipSSR = request.headers.get("Accept")?.includes("text/x-component");
+
+  const page = getPage(meta);
+
+  // This renders Server Components to a ReadableStream "RSC Payload"
+  const rscPayload = renderToPipeableStream(page, serverManifest)
+    // TODO: write a lightweight version of PassThrough
+    .pipe(new PassThrough());
+  if (skipSSR) {
+    return new Response(rscPayload as any, {
+      status: 200,
+      headers: { "Content-Type": "text/x-component" },
+    });
+  }
+
+  // Then the RSC payload is rendered into HTML
+  return new Response(await renderToHtml(rscPayload, meta.scripts), {
+    headers: {
+      "Content-Type": "text/html; charset=utf8",
+    },
+  });
+}
+
+// When a production build is performed, pre-rendering is invoked here. If this
+// function returns no files, the route is always dynamic. When building an app
+// to static files, all routes get pre-rendered (build failure if not possible).
+export async function prerender(meta: Bake.RouteMetadata) {
+  const page = getPage(meta);
+
+  const rscPayload = renderToPipeableStream(page, serverManifest)
+    // TODO: write a lightweight version of PassThrough
+    .pipe(new PassThrough());
+
+  let rscChunks: Uint8Array[] = [];
+  rscPayload.on("data", chunk => rscChunks.push(chunk));
+
+  const html = await renderToStaticHtml(rscPayload, meta.scripts);
+  const rsc = new Blob(rscChunks, { type: "text/x-component" });
+
+  return {
+    // Each route generates a directory with framework-provided files. Keys are
+    // files relative to the route path, and values are anything `Bun.write`
+    // supports. Streams may result in lower memory usage.
+    files: {
+      // Directories like `blog/index.html` are preferred over `blog.html` because
+      // certain static hosts do not support this conversion. By using `index.html`,
+      // the static build is more portable.
+      "/index.html": html,
+
+      // The RSC payload is provided so client-side can use this file for seamless
+      // client-side navigation. This is equivalent to 'Accept: text/x-component'
+      // for the non-static build.s
+      "/index.rsc": rsc,
+    },
+
+    // In the future, it will be possible to return data for a partially
+    // pre-rendered page instead of a fully rendered route. Bun might also
+    // expose caching options here.
+  };
+}
+
+// When a dynamic build uses static assets, Bun can map content types in the
+// user's `Accept` header to the different static files.
+export const contentTypeToStaticFile = {
+  "text/html": "index.html",
+  "text/x-component": "index.rsc",
+};
diff --git a/src/bake/bun-framework-react/ssr.tsx b/src/bake/bun-framework-react/ssr.tsx
new file mode 100644
index 00000000000000..f0d1cca88a11bf
--- /dev/null
+++ b/src/bake/bun-framework-react/ssr.tsx
@@ -0,0 +1,366 @@
+// This file is loaded in the SSR graph, meaning the `react-server` condition is
+// no longer set. This means we can import client components, using `react-dom`
+// to perform Server-side rendering (creating HTML) out of the RSC payload.
+import * as React from "react";
+import { clientManifest } from "bun:bake/server";
+import type { Readable } from "node:stream";
+import { EventEmitter } from "node:events";
+import { createFromNodeStream, type Manifest } from "react-server-dom-bun/client.node.unbundled.js";
+import { renderToPipeableStream } from "react-dom/server.node";
+
+// Verify that React 19 is being used.
+if (!React.use) {
+  throw new Error("Bun's React integration requires React 19");
+}
+
+const createFromNodeStreamOptions: Manifest = {
+  moduleMap: clientManifest,
+  moduleLoading: { prefix: "/" },
+};
+
+// The `renderToHtml` function not only implements converting the RSC payload
+// into HTML via react-dom, but also streaming the RSC payload via injected
+// script tags.  While the page is streaming, the client is loading the RSC
+// payload in the `__bun_f` ('f' meaning flight) global. `client.tsx` can
+// convert that array into a `ReadableStream` to incrementally hydrate the page.
+//
+// Some techniques have been taken from what Next.js and `rsc-html-stream` do,
+// but this version is [1] uses more efficient streaming APIs and [2] streams
+// the RSC data alongside the HTML, rather than injecting it at the very end.
+//
+// References:
+// - https://github.com/vercel/next.js/blob/15.0.2/packages/next/src/server/app-render/use-flight-response.tsx
+// - https://github.com/devongovett/rsc-html-stream
+export function renderToHtml(rscPayload: Readable, bootstrapModules: readonly string[]): ReadableStream {
+  // Bun supports a special type of readable stream type called "direct",
+  // which provides a raw handle to the controller. We can bypass all of
+  // the Web Streams API (slow) and use the controller directly.
+  let stream: RscInjectionStream | null = null;
+  let abort: () => void;
+  return new ReadableStream({
+    type: "direct",
+    pull(controller) {
+      // Initialize the injection stream so it gets the first "data" listener.
+      stream = new RscInjectionStream(rscPayload, controller);
+
+      // `createFromNodeStream` turns the RSC payload into a React component.
+      const promise = createFromNodeStream(rscPayload, {
+        // React takes in a manifest mapping client-side assets
+        // to the imports needed for server-side rendering.
+        moduleMap: clientManifest,
+        moduleLoading: { prefix: "/" },
+      });
+      // The root is this "Root" component that unwraps the streamed promise
+      // with `use`, and then returning the parsed React component for the UI.
+      const Root = () => React.use(promise);
+
+      // `renderToPipeableStream` is what actually generates HTML.
+      // Here is where React is told what script tags to inject.
+      let pipe: (stream: any) => void;
+      ({ pipe, abort } = renderToPipeableStream(<Root />, {
+        bootstrapModules,
+      }));
+      pipe(stream);
+
+      // Promise resolved after all data is combined.
+      return stream.finished;
+    },
+    cancel() {
+      stream?.destroy();
+      abort?.();
+    },
+  } as Bun.DirectUnderlyingSource as any);
+}
+
+// Static builds can not stream suspense boundaries as they finish, but instead
+// produce a single HTML blob. The approach is otherwise similar to `renderToHtml`.
+export function renderToStaticHtml(rscPayload: Readable, bootstrapModules: readonly string[]): Promise<Blob> {
+  const stream = new StaticRscInjectionStream(rscPayload);
+  const promise = createFromNodeStream(rscPayload, createFromNodeStreamOptions);
+  const Root = () => React.use(promise);
+  const { pipe } = renderToPipeableStream(<Root />, {
+    bootstrapModules,
+    // Only begin flowing HTML once all of it is ready. This tells React
+    // to not emit the flight chunks, just the entire HTML.
+    onAllReady: () => pipe(stream),
+  });
+  return stream.result;
+}
+
+const closingBodyTag = "</body></html>";
+const startScriptTag = "<script>(self.__bun_f||=[]).push(";
+const continueScriptTag = "<script>__bun_f.push(";
+
+const enum HtmlState {
+  /** HTML is flowing, it is not an okay time to inject RSC data. */
+  Flowing,
+  /** It is safe to inject RSC data. */
+  Boundary,
+}
+
+const enum RscState {
+  /** No RSC data has been written yet */
+  Waiting,
+  /** Some but not all RSC data has been written */
+  Paused,
+  /** All RSC data has been written */
+  Done,
+}
+
+class RscInjectionStream extends EventEmitter {
+  controller: ReadableStreamDirectController;
+
+  html: HtmlState = HtmlState.Flowing;
+  rsc: RscState = RscState.Waiting;
+
+  /** Chunks of RSC that will be injected at the next available point. */
+  rscChunks: Uint8Array[] = [];
+  /** If all RSC chunks have been processed */
+  rscHasEnded = false;
+  /** Shared state for decoding RSC data into UTF-8 strings */
+  decoder = new TextDecoder("utf-8", { fatal: true });
+
+  /** Resolved when all data is written */
+  finished: Promise<void>;
+  finalize: () => void;
+
+  constructor(rscPayload: Readable, controller: ReadableStreamDirectController) {
+    super();
+    this.controller = controller;
+
+    const { resolve, promise } = Promise.withResolvers<void>();
+    this.finished = promise;
+    this.finalize = resolve;
+
+    rscPayload.on("data", this.writeRscData.bind(this));
+    rscPayload.on("end", () => {
+      this.rscHasEnded = true;
+    });
+  }
+
+  write(data: Uint8Array) {
+    if (endsWithClosingScript(data)) {
+      // The HTML is not done yet, but it's a suitible time to inject RSC data.
+      const { controller } = this;
+      controller.write(data);
+      this.html = HtmlState.Boundary;
+      this.drainRscChunks();
+    } else if (endsWithClosingBody(data)) {
+      // The HTML is about to finish. When this happens there cannot be more RSC
+      // chunks, since if that was truly the case, the HTML wouldn't be done.
+      const { controller } = this;
+      controller.write(data.subarray(0, data.length - closingBodyTag.length));
+      this.drainRscChunks();
+      controller.write(closingBodyTag);
+      controller.end();
+      this.finalize();
+    } else {
+      this.controller.write(data);
+      this.html = HtmlState.Flowing;
+    }
+  }
+
+  drainRscChunks() {
+    const { rsc } = this;
+    if (rsc === RscState.Done) return;
+
+    const { controller, decoder, rscChunks } = this;
+    if (rscChunks.length === 0) return;
+
+    if (rsc === RscState.Waiting) {
+      controller.write(startScriptTag);
+    } else {
+      controller.write(continueScriptTag);
+      this.rsc = RscState.Paused;
+    }
+    writeManyFlightScriptData(rscChunks, decoder, controller);
+    if (this.rscHasEnded) {
+      this.rsc = RscState.Done;
+    }
+    this.rscChunks = [];
+  }
+
+  writeRscData(chunk: Uint8Array) {
+    if (this.html === HtmlState.Boundary) {
+      const { controller, decoder } = this;
+      if (this.rsc === RscState.Waiting) {
+        controller.write(startScriptTag);
+      } else {
+        controller.write(continueScriptTag);
+        this.rsc = RscState.Paused;
+      }
+      writeSingleFlightScriptData(chunk, decoder, controller);
+    } else {
+      this.rscChunks.push(chunk);
+    }
+  }
+
+  flush() {
+    // Ignore flush requests from React. Bun will automatically flush when reasonable.
+  }
+
+  destroy() {
+    // TODO:
+  }
+
+  end() {
+    this.finalize();
+  }
+}
+
+class StaticRscInjectionStream extends EventEmitter {
+  rscPayloadChunks: Uint8Array[] = [];
+  chunks: (Uint8Array | string)[] = [];
+  result: Promise<Blob>;
+  finalize: (blob: Blob) => void;
+  reject: (error: Error) => void;
+
+  constructor(rscPayload: Readable) {
+    super();
+    const { resolve, promise, reject } = Promise.withResolvers<Blob>();
+    this.result = promise;
+    this.finalize = resolve;
+    this.reject = reject;
+
+    rscPayload.on("data", chunk => this.rscPayloadChunks.push(chunk));
+  }
+
+  write(chunk) {
+    this.chunks.push(chunk);
+  }
+
+  end() {
+    // Inject the finalized RSC payload into the last chunk
+    const lastChunk = this.chunks[this.chunks.length - 1];
+
+    // Release assertions for React's behavior. If these break there will be malformed HTML.
+    if (typeof lastChunk === "string") {
+      this.destroy(new Error("The last chunk was expected to be a Uint8Array"));
+      return;
+    }
+    if (!endsWithClosingBody(lastChunk)) {
+      this.destroy(new Error("The last chunk did not end with a closing </body></html> tag"));
+      return;
+    }
+    this.chunks[this.chunks.length - 1] = lastChunk.slice(0, lastChunk.length - closingBodyTag.length);
+
+    let string = startScriptTag;
+    writeManyFlightScriptData(this.rscPayloadChunks, new TextDecoder("utf-8"), { write: str => (string += str) });
+    this.chunks.push(string + closingBodyTag);
+    this.finalize(new Blob(this.chunks, { type: "text/html" }));
+  }
+
+  flush() {
+    // Ignore flush requests from React.
+  }
+
+  destroy(error) {
+    console.error(error);
+    this.reject(error);
+  }
+}
+
+/** Assumes the opening script tag and function call have been written */
+function writeSingleFlightScriptData(
+  chunk: Uint8Array,
+  decoder: TextDecoder,
+  controller: { write: (str: string) => void },
+) {
+  try {
+    // `decode()` will throw on invalid UTF-8 sequences.
+    controller.write("'" + toSingleQuote(decoder.decode(chunk, { stream: true })) + "')</script>");
+  } catch {
+    // The chunk cannot be embedded as a UTF-8 string in the script tag.
+    // No data should have been written yet, so a base64 fallback can be used.
+    const base64 = btoa(String.fromCodePoint(...chunk));
+    controller.write(`Uint8Array.from(atob(\"${base64}\"),m=>m.codePointAt(0))</script>`);
+  }
+}
+
+/**
+ * Attempts to combine RSC chunks together to minimize the number of chunks the
+ * client processes.
+ */
+function writeManyFlightScriptData(
+  chunks: Uint8Array[],
+  decoder: TextDecoder,
+  controller: { write: (str: string) => void },
+) {
+  if (chunks.length === 1) return writeSingleFlightScriptData(chunks[0], decoder, controller);
+
+  let i = 0;
+  try {
+    // Combine all chunks into a single string if possible.
+    for (; i < chunks.length; i++) {
+      // `decode()` will throw on invalid UTF-8 sequences.
+      const str = toSingleQuote(decoder.decode(chunks[i], { stream: true }));
+      if (i === 0) controller.write("'");
+      controller.write(str);
+    }
+    controller.write("')</script>");
+  } catch {
+    // The chunk cannot be embedded as a UTF-8 string in the script tag.
+    // Since this is rare, just make the rest of the chunks base64.
+    if (i > 0) controller.write("');__bun_f.push(");
+    controller.write('Uint8Array.from(atob("');
+    for (; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const base64 = btoa(String.fromCodePoint(...chunk));
+      controller.write(base64.slice(1, -1));
+    }
+    controller.write('"),m=>m.codePointAt(0))</script>');
+  }
+}
+
+// Instead of using `JSON.stringify`, this uses a single quote variant of it, since
+// the RSC payload includes a ton of " characters. This is slower, but an easy
+// component to move into native code.
+function toSingleQuote(str: string): string {
+  return (
+    str // Escape single quotes, backslashes, and newlines
+      .replace(/\\/g, "\\\\")
+      .replace(/'/g, "\\'")
+      .replace(/\n/g, "\\n")
+      // Escape closing script tags and HTML comments in JS content.
+      .replace(/<!--/g, "<\\!--")
+      .replace(/<\/(script)/gi, "</\\$1")
+  );
+}
+
+// Note that the bundler special cases constant folding for `charCodeAt`.
+function endsWithClosingScript(view: Uint8Array): boolean {
+  const length = view.length;
+  return (
+    length >= 9 &&
+    view[length - 9] === "<".charCodeAt(0) &&
+    view[length - (9 - 1)] === "/".charCodeAt(0) &&
+    view[length - (9 - 2)] === "s".charCodeAt(0) &&
+    view[length - (9 - 3)] === "c".charCodeAt(0) &&
+    view[length - (9 - 4)] === "r".charCodeAt(0) &&
+    view[length - (9 - 5)] === "i".charCodeAt(0) &&
+    view[length - (9 - 6)] === "p".charCodeAt(0) &&
+    view[length - (9 - 7)] === "t".charCodeAt(0) &&
+    view[length - (9 - 8)] === ">".charCodeAt(0)
+  );
+}
+
+function endsWithClosingBody(view: Uint8Array): boolean {
+  const length = view.length;
+  return (
+    length >= 14 &&
+    view[length - 14] === "<".charCodeAt(0) &&
+    view[length - (14 - 1)] === "/".charCodeAt(0) &&
+    view[length - (14 - 2)] === "b".charCodeAt(0) &&
+    view[length - (14 - 3)] === "o".charCodeAt(0) &&
+    view[length - (14 - 4)] === "d".charCodeAt(0) &&
+    view[length - (14 - 5)] === "y".charCodeAt(0) &&
+    view[length - (14 - 6)] === ">".charCodeAt(0) &&
+    view[length - (14 - 7)] === "<".charCodeAt(0) &&
+    view[length - (14 - 8)] === "/".charCodeAt(0) &&
+    view[length - (14 - 9)] === "h".charCodeAt(0) &&
+    view[length - (14 - 10)] === "t".charCodeAt(0) &&
+    view[length - (14 - 11)] === "m".charCodeAt(0) &&
+    view[length - (14 - 12)] === "l".charCodeAt(0) &&
+    view[length - (14 - 13)] === ">".charCodeAt(0)
+  );
+}
diff --git a/src/bake/bun-framework-rsc/client.tsx b/src/bake/bun-framework-rsc/client.tsx
deleted file mode 100644
index 94548349df600c..00000000000000
--- a/src/bake/bun-framework-rsc/client.tsx
+++ /dev/null
@@ -1,41 +0,0 @@
-/// <reference lib="dom" />
-import { use } from "react";
-import { hydrateRoot } from "react-dom/client";
-import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
-
-function assertionFailed(msg: string) {
-  throw new Error(`Assertion Failure: ${msg}. This is a bug in Bun's React integration`);
-}
-
-// Client-side entry point expects an RSC payload. In development, let's fail
-// loudly if this is somehow missing.
-const initialPayload = document.getElementById("rsc_payload");
-if (import.meta.env.DEV) {
-  if (!initialPayload) assertionFailed("Missing #rsc_payload in HTML response");
-}
-
-// React takes in a ReadableStream with the payload.
-let promise = createFromReadableStream(new Response(initialPayload!.innerText).body!);
-initialPayload!.remove();
-
-const Async = () => use(promise);
-const root = hydrateRoot(document, <Async />, {
-  // handle `onUncaughtError` here
-});
-
-export async function onServerSideReload() {
-  const response = await fetch(location.href + '/index.rsc', {
-    headers: {
-      Accept: "text/x-component",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-
-  promise = createFromReadableStream(response.body!);
-  root.render(<Async />);
-}
-
-globalThis.onServerSideReload = onServerSideReload;
diff --git a/src/bake/bun-framework-rsc/index.ts b/src/bake/bun-framework-rsc/index.ts
deleted file mode 100644
index 4e104a7d939da3..00000000000000
--- a/src/bake/bun-framework-rsc/index.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-// This file is unused by Bun itself, but rather is a tool for
-// contributors to hack on `bun-framework-react` without needing
-// to compile bun itself. If changes to this are made, please
-// update 'pub fn react' in 'bake.zig'
-import type { Bake } from "bun";
-
-export function react(): Bake.Framework {
-  return {
-    // When the files are embedded in the Bun binary, relative
-    // path resolution does not work.
-    builtInModules: {
-      'bun-framework-react/client.tsx': { path: require.resolve('./client.tsx') },
-      'bun-framework-react/server.tsx': { path: require.resolve('./server.tsx') },
-      'bun-framework-react/ssr.tsx': { path: require.resolve('./ssr.tsx') },
-    },
-    clientEntryPoint: "bun-framework-react/client.tsx",
-    serverEntryPoint: "bun-framework-react/server.tsx",
-    reactFastRefresh: {
-      importSource: "react-refresh/runtime",
-    },
-    serverComponents: {
-      separateSSRGraph: true,
-      serverRegisterClientReferenceExport: 'registerClientReference',
-      serverRuntimeImportSource: 'react-server-dom-webpack/server'
-    }
-  };
-}
\ No newline at end of file
diff --git a/src/bake/bun-framework-rsc/server.tsx b/src/bake/bun-framework-rsc/server.tsx
deleted file mode 100644
index 4ce082e96007af..00000000000000
--- a/src/bake/bun-framework-rsc/server.tsx
+++ /dev/null
@@ -1,127 +0,0 @@
-import type { Bake } from "bun";
-import { renderToReadableStream } from "react-server-dom-webpack/server.browser";
-import { renderToHtml } from "bun-framework-rsc/ssr.tsx" with { bunBakeGraph: "ssr" };
-import { clientManifest, serverManifest } from "bun:bake/server";
-import { join } from 'node:path';
-
-function getPage(route, meta: Bake.RouteMetadata) {
-  const Route = route.default;
-  const { styles } = meta;
-
-  if (import.meta.env.DEV) {
-    if (typeof Route !== "function") {
-      throw new Error(
-        "Expected the default export of " +
-          JSON.stringify(meta.devRoutePath) +
-          " to be a React component, got " +
-          JSON.stringify(Route),
-      );
-    }
-  }
-
-  return (
-    <html lang="en">
-      <head>
-        <meta name="viewport" content="width=device-width, initial-scale=1" />
-        <title>Bun + React Server Components</title>
-        {styles.map(url => (
-          <link key={url} rel="stylesheet" href={url} />
-        ))}
-      </head>
-      <body>
-        <Route />
-      </body>
-    </html>
-  );
-}
-
-// `server.tsx` exports a function to be used for handling user routes. It takes
-// in the Request object, the route's module, and extra route metadata.
-export default async function render(request: Request, route: any, meta: Bake.RouteMetadata): Promise<Response> {
-  // The framework generally has two rendering modes.
-  // - Standard browser navigation
-  // - Client-side navigation
-  //
-  // For React, this means we will always perform `renderToReadableStream` to
-  // generate the RSC payload, but only generate HTML for the former of these
-  // rendering modes. This is signaled by `client.tsx` via the `Accept` header.
-  const skipSSR = request.headers.get("Accept")?.includes("text/x-component");
-
-  const page = getPage(route, meta);
-
-  // This renders Server Components to a ReadableStream "RSC Payload"
-  const rscPayload = renderToReadableStream(page, serverManifest);
-  if (skipSSR) {
-    return new Response(rscPayload, {
-      status: 200,
-      headers: { "Content-Type": "text/x-component" },
-    });
-  }
-
-  // One straem is used to render SSR. The second is embedded into the html for browser hydration.
-  // Note: This approach does not stream the response. That practice is called "react flight" and should be added
-  const [rscPayload1, rscPayload2] = rscPayload.tee();
-  const rscPayloadBuffer = Bun.readableStreamToText(rscPayload1);
-  const rw = new HTMLRewriter();
-  rw.on("body", {
-    element(element) {
-      element.onEndTag(async end => {
-        end.before(
-          `<script id="rsc_payload" type="json">${await rscPayloadBuffer}</script>` +
-            meta.scripts.map(url => `<script src=${JSON.stringify(url)}></script>`).join(""),
-          { html: true },
-        );
-      });
-    },
-  });
-  // TODO: readableStreamToText is needed due to https://github.com/oven-sh/bun/issues/14216
-  const output = await Bun.readableStreamToText(await renderToHtml(rscPayload2));
-  return rw.transform(
-    new Response(output, {
-      headers: {
-        "Content-Type": "text/html; charset=utf8",
-      },
-    }),
-  );
-}
-
-// For static site generation, a different function is given, one without a request object.
-export async function renderStatic(route: any, meta: Bake.RouteMetadata) {
-  const page = getPage(route, meta);
-  const rscPayload = renderToReadableStream(page, serverManifest);
-  const [rscPayload1, rscPayload2] = rscPayload.tee();
-  
-  // Prepare both files in parallel
-  let [html, rscPayloadBuffer] = await Promise.all([
-    Bun.readableStreamToText(await renderToHtml(rscPayload2)),
-    Bun.readableStreamToText(rscPayload1),
-  ]);
-  const scripts = meta.scripts.map(url => `<script src=${JSON.stringify(url)}></script>`);
-  html = html.replace('</body>', `<script id="rsc_payload" type="json">${rscPayloadBuffer}</script>${scripts.join('\n')}</body>`);
-
-  // Each route generates a directory with framework-provided files. Keys are
-  // files relative to the route path, and values are anything `Bun.write`
-  // supports. Streams may result in lower memory usage.
-  return {
-    // Directories like `blog/index.html` are preferred over `blog.html` because
-    // certain static hosts do not support this conversion. By using `index.html`,
-    // the static build is more portable.
-    '/index.html': html,
-
-    // The RSC payload is provided so client-side can use this file for seamless
-    // client-side navigation. This is equivalent to 'Accept: text/x-component'
-    // for the non-static build.s
-    '/index.rsc': rscPayloadBuffer,
-  }
-}
-
-// This is a hack to make react-server-dom-webpack work with Bun's bundler.
-// It will be removed once Bun acquires react-server-dom-bun.
-if (!import.meta.env.DEV) {
-  globalThis.__webpack_require__ = (id: string) => {
-    console.log("Bun: __webpack_require__", id);
-    const y = import.meta.require(join(import.meta.dir, id));
-    console.log({y});
-    return y;
-  };
-}
diff --git a/src/bake/bun-framework-rsc/ssr.tsx b/src/bake/bun-framework-rsc/ssr.tsx
deleted file mode 100644
index 89eea077248efe..00000000000000
--- a/src/bake/bun-framework-rsc/ssr.tsx
+++ /dev/null
@@ -1,16 +0,0 @@
-// This file is loaded in the SSR graph, meaning the `react-server` condition is
-// no longer set. This means we can import client components, using `react-dom`
-// to perform SSR from the RSC payload.
-import { use } from "react";
-import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
-import { renderToReadableStream } from "react-dom/server";
-import { clientManifest } from "bun:bake/server";
-
-export function renderToHtml(rscPayload: ReadableStream): Promise<ReadableStream> {
-  const promise = createFromReadableStream(rscPayload, {
-    moduleMap: clientManifest,
-    moduleLoading: { prefix: "" },
-  });
-  const Async = () => use(promise);
-  return renderToReadableStream(<Async />);
-}
diff --git a/src/bake/hmr-module.ts b/src/bake/hmr-module.ts
index 4ddd70f9be0795..b085898075c1a2 100644
--- a/src/bake/hmr-module.ts
+++ b/src/bake/hmr-module.ts
@@ -84,35 +84,36 @@ function initImportMeta(m: HotModule): ImportMeta {
  * present, or is something a user is able to dynamically specify.
  */
 export function loadModule<T = any>(key: Id, type: LoadModuleType): HotModule<T> {
-  let module = registry.get(key);
-  if (module) {
+  let mod = registry.get(key);
+  if (mod) {
     // Preserve failures until they are re-saved.
-    if (module._state == State.Error) throw module._cached_failure;
+    if (mod._state == State.Error) throw mod._cached_failure;
 
-    return module;
+    return mod;
   }
-  module = new HotModule(key);
+  mod = new HotModule(key);
   const load = input_graph[key];
   if (!load) {
     if (type == LoadModuleType.AssertPresent) {
       throw new Error(
-        `Failed to load bundled module '${key}'. This is not a dynamic import, and therefore is a bug in Bun Kit's bundler.`,
+        `Failed to load bundled module '${key}'. This is not a dynamic import, and therefore is a bug in Bun's bundler.`,
       );
     } else {
       throw new Error(
-        `Failed to resolve dynamic import '${key}'. In Bun Kit, all imports must be statically known at compile time so that the bundler can trace everything.`,
+        `Failed to resolve dynamic import '${key}'. In Bun Bake, all imports must be statically known at compile time so that the bundler can trace everything.`,
       );
     }
   }
   try {
-    registry.set(key, module);
-    load(module);
+    registry.set(key, mod);
+    load(mod);
   } catch (err) {
-    module._cached_failure = err;
-    module._state = State.Error;
+    console.error(err);
+    mod._cached_failure = err;
+    mod._state = State.Error;
     throw err;
   }
-  return module;
+  return mod;
 }
 
 export const getModule = registry.get.bind(registry);
@@ -169,16 +170,14 @@ if (side === "client") {
     refreshRuntime = loadModule(refresh, LoadModuleType.AssertPresent).exports;
     refreshRuntime.injectIntoGlobalHook(window);
   }
-}
 
-// TODO: Remove this after `react-server-dom-bun` is uploaded
-globalThis.__webpack_require__ = (id: string) => {
-  if (side == "server" && config.separateSSRGraph && !id.startsWith("ssr:")) {
-    return loadModule("ssr:" + id, LoadModuleType.UserDynamic).exports;
-  } else {
-    return loadModule(id, LoadModuleType.UserDynamic).exports;
-  }
-};
+  const server_module = new HotModule("bun:bake/client");
+  server_module.__esModule = true;
+  server_module.exports = {
+    bundleRouteForDevelopment: async () => {},
+  };
+  registry.set(server_module.id, server_module);
+}
 
 runtimeHelpers.__name(HotModule.prototype.importSync, "<HMR runtime> importSync");
 runtimeHelpers.__name(HotModule.prototype.require, "<HMR runtime> require");
diff --git a/src/bake/hmr-runtime-server.ts b/src/bake/hmr-runtime-server.ts
index da5cd0935c9661..67670be8599239 100644
--- a/src/bake/hmr-runtime-server.ts
+++ b/src/bake/hmr-runtime-server.ts
@@ -1,36 +1,66 @@
 // This file is the entrypoint to the hot-module-reloading runtime.
-// On the server, communication is facilitated using the default
-// export, which is assigned via `server_exports`.
+// On the server, communication is established with `server_exports`.
 import type { Bake } from "bun";
-import { loadModule, LoadModuleType, replaceModules, clientManifest, serverManifest, getModule } from "./hmr-module";
+import { loadModule, LoadModuleType, replaceModules, clientManifest, serverManifest } from "./hmr-module";
 
 if (typeof IS_BUN_DEVELOPMENT !== "boolean") {
   throw new Error("DCE is configured incorrectly");
 }
 
+interface Exports {
+  handleRequest: (
+    req: Request,
+    routerTypeMain: Id,
+    routeModules: Id[],
+    clientEntryUrl: string,
+    styles: string[],
+    params: Record<string, string> | null,
+  ) => any;
+  registerUpdate: (
+    modules: any,
+    componentManifestAdd: null | string[],
+    componentManifestDelete: null | string[],
+  ) => void;
+}
+
+declare let server_exports: Exports;
 server_exports = {
-  async handleRequest(req, routeModuleId, clientEntryUrl, styles) {
-    const serverRenderer = loadModule<Bake.ServerEntryPoint>(config.main, LoadModuleType.AssertPresent).exports.default;
+  async handleRequest(req, routerTypeMain, routeModules, clientEntryUrl, styles, params) {
+    if (IS_BUN_DEVELOPMENT) {
+      console.log("handleRequest", {
+        routeModules,
+        clientEntryUrl,
+        styles,
+        params,
+      });
+    }
+
+    const serverRenderer = loadModule<Bake.ServerEntryPoint>(routerTypeMain, LoadModuleType.AssertPresent).exports
+      .render;
 
     if (!serverRenderer) {
-      throw new Error('Framework server entrypoint is missing a "default" export.');
+      throw new Error('Framework server entrypoint is missing a "render" export.');
     }
     if (typeof serverRenderer !== "function") {
-      throw new Error('Framework server entrypoint\'s "default" export is not a function.');
+      throw new Error('Framework server entrypoint\'s "render" export is not a function.');
     }
 
-    const response = await serverRenderer(req, loadModule(routeModuleId, LoadModuleType.AssertPresent).exports, {
+    const [pageModule, ...layouts] = routeModules.map(id => loadModule(id, LoadModuleType.AssertPresent).exports);
+
+    const response = await serverRenderer(req, {
       styles: styles,
       scripts: [clientEntryUrl],
-      devRoutePath: routeModuleId,
+      layouts,
+      pageModule,
+      modulepreload: [],
+      params,
     });
 
     if (!(response instanceof Response)) {
       throw new Error(`Server-side request handler was expected to return a Response object.`);
     }
 
-    // TODO: support streaming
-    return await response.text();
+    return response;
   },
   registerUpdate(modules, componentManifestAdd, componentManifestDelete) {
     replaceModules(modules);
@@ -42,14 +72,21 @@ server_exports = {
           const { exports, __esModule } = mod;
           const exp = __esModule ? exports : (mod._ext_exports ??= { ...exports, default: exports });
 
+          const client = {};
           for (const exportName of Object.keys(exp)) {
             serverManifest[uid] = {
               id: uid,
               name: exportName,
               chunks: [],
             };
+            client[exportName] = {
+              specifier: "ssr:" + uid,
+              name: exportName,
+            };
           }
+          clientManifest[uid] = client;
         } catch (err) {
+          console.log("caught error");
           console.log(err);
         }
       }
@@ -65,4 +102,4 @@ server_exports = {
       }
     }
   },
-};
+} satisfies Exports;
diff --git a/src/bake/incremental_visualizer.html b/src/bake/incremental_visualizer.html
index 3e72944da4dd10..8e4b2d9e356cde 100644
--- a/src/bake/incremental_visualizer.html
+++ b/src/bake/incremental_visualizer.html
@@ -59,13 +59,6 @@ <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
         blue: "#89b4fa",
         yellow: "#f9e2af",
       };
-      const ws = new WebSocket(location.origin + "/_bun/hmr");
-
-      ws.binaryType = "arraybuffer"; // We are expecting binary data
-
-      ws.onopen = function () {
-        ws.send(new Uint8Array([118])); // Send 'v' byte to initiate connection
-      };
 
       // Store nodes and edges
       let clientFiles = [];
@@ -74,15 +67,34 @@ <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
       let serverEdges = [];
       let currentEdgeIds = new Set();
       let currentNodeIds = new Set();
-      let isFirst = true;
+      let = true;
+
+      // Initialize Vis.js network
+      const nodes = new vis.DataSet();
+      const edges = new vis.DataSet();
 
-      // When a message is received
-      ws.onmessage = function (event) {
-        const buffer = new Uint8Array(event.data);
+      const container = document.getElementById("network");
+      const data = { nodes, edges };
+      const options = {};
+      const network = new vis.Network(container, data, options);
+
+      // Crash handler injects `inlinedData` to produce an offline-compatible version of IncrementalVisualizer
+      if (typeof inlinedData !== "undefined") {
+        decodeAndUpdate(inlinedData);
+      } else {
+        const ws = new WebSocket(location.origin + "/_bun/hmr");
+        ws.binaryType = "arraybuffer"; // We are expecting binary data
+        ws.onopen = function () {
+          ws.send(new Uint8Array([118])); // Send 'v' byte to initiate connection
+        };
+        ws.onmessage = function (event) {
+          decodeAndUpdate(new Uint8Array(event.data));
+        };
+      }
 
+      function decodeAndUpdate(buffer) {
         // Only process messages starting with 'v' (ASCII code 118)
         if (buffer[0] !== 118) return;
-        console.log("Got Event");
 
         let offset = 1; // Skip the 'v' byte
 
@@ -118,7 +130,7 @@ <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
 
         // Update the graph visualization
         updateGraph();
-      };
+      }
 
       // Helper to read 4-byte unsigned int
       function readUint32(buffer, offset) {
@@ -126,7 +138,8 @@ <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
       }
 
       function basename(path) {
-        return path.slice(path.lastIndexOf("/") + 1);
+        const match = /node_modules\/(.*?)\//.exec(path);
+        return match ? match[1] : path;
       }
 
       // Parse the files from the buffer
@@ -182,22 +195,13 @@ <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
         return { edges, offset };
       }
 
-      // Initialize Vis.js network
-      const nodes = new vis.DataSet();
-      const edges = new vis.DataSet();
-
-      const container = document.getElementById("network");
-      const data = { nodes, edges };
-      const options = {};
-      const network = new vis.Network(container, data, options);
-
       // Helper function to add or update nodes in the graph
       function updateNode(id, file, group) {
         const label = basename(file.name);
-        const color = file.name.includes("/node_modules/")
-          ? c.gray
-          : file.isStale
-            ? c.red
+        const color = file.isStale
+          ? c.red
+          : file.name.startsWith("node_modules/")
+            ? c.gray
             : file.isBoundary
               ? c.orange
               : group === "client"
@@ -216,7 +220,7 @@ <h1>IncrementalGraph Visualization <span id="stat"></span></h1>
           color: color,
           borderWidth: file.isRoute ? 3 : 1,
           group,
-          font: file.name.includes("/node_modules/") ? "10px sans-serif #cdd6f488" : "20px sans-serif #cdd6f4",
+          font: file.name.startsWith("node_modules/") ? "10px sans-serif #cdd6f488" : "20px sans-serif #cdd6f4",
         };
         if (nodes.get(id)) {
           nodes.update(props);
diff --git a/src/bake/package.json b/src/bake/package.json
index a43829151e1423..725a78688b00ae 100644
--- a/src/bake/package.json
+++ b/src/bake/package.json
@@ -1,3 +1,4 @@
 {
-  "sideEffects": false
+  "sideEffects": false,
+  "type": "module"
 }
diff --git a/src/bake/production.zig b/src/bake/production.zig
index 88e590ced349cd..394146d84933ba 100644
--- a/src/bake/production.zig
+++ b/src/bake/production.zig
@@ -1,11 +1,7 @@
 //! Implements building a Bake application to production
+const log = bun.Output.scoped(.production, false);
 
 pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
-    if (!bun.Environment.isDebug) {
-        Output.errGeneric("Not yet stable. Sorry!", .{});
-        bun.Global.crash();
-    }
-
     Output.warn(
         \\Be advised that Bun Bake is highly experimental, and its API
         \\will have breaking changes. Join the <magenta>#bake<r> Discord
@@ -26,24 +22,32 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
     }
 
     var cwd_buf: bun.PathBuffer = undefined;
-    const cwd = try bun.getcwd(&cwd_buf);
+    const cwd = bun.getcwd(&cwd_buf) catch |err| {
+        Output.err(err, "Could not query current working directory", .{});
+        bun.Global.crash();
+    };
 
     // Create a VM + global for loading the config file, plugins, and
     // performing build time prerendering.
     bun.JSC.initialize(false);
     bun.JSAst.Expr.Data.Store.create();
     bun.JSAst.Stmt.Data.Store.create();
+
     var arena = try bun.MimallocArena.init();
     defer arena.deinit();
-    const allocator = bun.default_allocator;
-    const vm = try VirtualMachine.init(.{
+
+    const vm = try VirtualMachine.initBake(.{
         .allocator = arena.allocator(),
         .log = ctx.log,
         .args = ctx.args,
         .smol = ctx.runtime_options.smol,
     });
     defer vm.deinit();
-    var b = &vm.bundler;
+    vm.global = BakeCreateProdGlobal(vm.console);
+    vm.regular_event_loop.global = vm.global;
+    vm.jsc = vm.global.vm();
+    vm.event_loop.ensureWaker();
+    const b = &vm.bundler;
     vm.preload = ctx.preloads;
     vm.argv = ctx.passthrough;
     vm.arena = &arena;
@@ -83,8 +87,25 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
 
     const api_lock = vm.jsc.getAPILock();
     defer api_lock.release();
+    buildWithVm(ctx, cwd, vm) catch |err| switch (err) {
+        error.JSError => |e| {
+            bun.handleErrorReturnTrace(err, @errorReturnTrace());
+            vm.printErrorLikeObjectToConsole(vm.global.takeException(e));
+            if (vm.exit_handler.exit_code == 0) {
+                vm.exit_handler.exit_code = 1;
+            }
+            vm.globalExit();
+        },
+        else => |e| return e,
+    };
+}
 
+pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMachine) !void {
     // Load and evaluate the configuration module
+    const global = vm.global;
+    const b = &vm.bundler;
+    const allocator = bun.default_allocator;
+
     Output.prettyErrorln("Loading configuration", .{});
     Output.flush();
     const unresolved_config_entry_point = if (ctx.args.entry_points.len > 0) ctx.args.entry_points[0] else "./bun.app";
@@ -110,9 +131,12 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
 
     const config_entry_point_string = bun.String.createUTF8(config_entry_point.pathConst().?.text);
     defer config_entry_point_string.deref();
-    const config_promise = bun.JSC.JSModuleLoader.loadAndEvaluateModule(vm.global, &config_entry_point_string) orelse {
-        @panic("TODO");
+
+    const config_promise = bun.JSC.JSModuleLoader.loadAndEvaluateModule(global, &config_entry_point_string) orelse {
+        bun.assert(global.hasException());
+        return error.JSError;
     };
+
     vm.waitForPromise(.{ .internal = config_promise });
     var options = switch (config_promise.unwrap(vm.jsc, .mark_handled)) {
         .pending => unreachable,
@@ -124,17 +148,11 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
                 Output.panic("TODO: print this error better, default export is not an object", .{});
             }
 
-            const app = default.get(vm.global, "app") orelse {
+            const app = try default.get2(vm.global, "app") orelse {
                 Output.panic("TODO: print this error better, default export needs an 'app' object", .{});
             };
 
-            if (vm.global.hasException()) {
-                @panic("pending exception");
-            }
-
-            break :config bake.bakeOptionsFromJs(vm.global, app) catch |err| {
-                Output.panic("TODO, print this error better: {}", .{err});
-            };
+            break :config try bake.UserOptions.fromJS(app, vm.global);
         },
         .rejected => |err| {
             // dont run on rejected since we fail the build here
@@ -161,13 +179,13 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
     var client_bundler: bun.bundler.Bundler = undefined;
     var server_bundler: bun.bundler.Bundler = undefined;
     var ssr_bundler: bun.bundler.Bundler = undefined;
-    try framework.initBundler(allocator, vm.log, .production, .server, &server_bundler);
-    try framework.initBundler(allocator, vm.log, .production, .client, &client_bundler);
+    try framework.initBundler(allocator, vm.log, .production_static, .server, &server_bundler);
+    try framework.initBundler(allocator, vm.log, .production_static, .client, &client_bundler);
     if (separate_ssr_graph) {
-        try framework.initBundler(allocator, vm.log, .production, .ssr, &ssr_bundler);
+        try framework.initBundler(allocator, vm.log, .production_static, .ssr, &ssr_bundler);
     }
 
-    // these share pointers right now, so setting NODE_ENV == production
+    // these share pointers right now, so setting NODE_ENV == production on one should affect all
     bun.assert(server_bundler.env == client_bundler.env);
 
     framework.* = framework.resolve(&server_bundler.resolver, &client_bundler.resolver) catch {
@@ -183,23 +201,49 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
 
     var root_dir_buf: bun.PathBuffer = undefined;
     const root_dir_path = bun.path.joinAbsStringBuf(cwd, &root_dir_buf, &.{"dist"}, .auto);
-    const root_path_trailing = root_dir_path.ptr[0 .. root_dir_path.len + 1];
-    _ = root_path_trailing; // autofix
-    root_dir_buf[root_dir_path.len] = std.fs.path.sep;
-    // server_bundler.options.public_path = root_path_trailing;
-    // server_bundler.resolver.opts.public_path = root_path_trailing;
-
-    var entry_points = std.ArrayList(BakeEntryPoint).init(allocator);
-    // the ordering of these entrypoints is relied on when inspecting the output chunks.
-    try entry_points.append(BakeEntryPoint.init(framework.entry_server, .server));
-    try entry_points.append(BakeEntryPoint.initClientWrapped(framework.entry_client, .client));
-
-    for (options.routes) |route| {
-        try entry_points.append(BakeEntryPoint.init(route.entry_point, .server));
+    // const root_path_trailing = root_dir_path.ptr[0 .. root_dir_path.len + 1];
+    // root_dir_buf[root_dir_path.len] = std.fs.path.sep;
+    // _ = root_path_trailing;
+
+    var router_types = try std.ArrayListUnmanaged(FrameworkRouter.Type).initCapacity(allocator, options.framework.file_system_router_types.len);
+
+    var path_map: ProductionPathMap = .{
+        .allocator = allocator,
+        .entry_points = .{},
+        .route_files = .{},
+        .out_index_map = &.{},
+        .out_module_keys = &.{},
+    };
+
+    for (options.framework.file_system_router_types, 0..) |fsr, i| {
+        const joined_root = bun.path.joinAbs(cwd, .auto, fsr.root);
+        const entry = server_bundler.resolver.readDirInfoIgnoreError(joined_root) orelse
+            continue;
+        try router_types.append(allocator, .{
+            .abs_root = bun.strings.withoutTrailingSlash(entry.abs_path),
+            .prefix = fsr.prefix,
+            .ignore_underscores = fsr.ignore_underscores,
+            .ignore_dirs = fsr.ignore_dirs,
+            .extensions = fsr.extensions,
+            .style = fsr.style,
+            .server_file = try path_map.getFileIdForRouter(fsr.entry_server, FrameworkRouter.Route.Index.init(@intCast(i)), .page),
+            .client_file = if (fsr.entry_client) |client|
+                (try path_map.getClientFile(client)).toOptional()
+            else
+                .none,
+            .server_file_string = .{},
+        });
     }
 
-    const bundled_outputs = try bun.BundleV2.generateFromBakeProductionCLI(
-        entry_points.items,
+    var router = try FrameworkRouter.initEmpty(router_types.items, allocator);
+    try router.scanAll(
+        allocator,
+        &server_bundler.resolver,
+        FrameworkRouter.InsertionContext.wrap(ProductionPathMap, &path_map),
+    );
+
+    const bundled_outputs_list = try bun.BundleV2.generateFromBakeProductionCLI(
+        path_map.entry_points.items,
         &server_bundler,
         .{
             .framework = framework.*,
@@ -209,47 +253,44 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
         allocator,
         .{ .js = vm.event_loop },
     );
+    const bundled_outputs = bundled_outputs_list.items;
 
     Output.prettyErrorln("Rendering routes", .{});
     Output.flush();
 
-    // A separate global object is used for isolation + controlling the available modules
-    const render_global = BakeCreateProdGlobal(vm.jsc, vm.console);
-
     var root_dir = try std.fs.cwd().makeOpenPath("dist", .{});
     defer root_dir.close();
 
-    var client_entry_id: u32 = std.math.maxInt(u32);
-
-    var server_entry_module_key: JSValue = .undefined;
-    const route_module_keys = JSValue.createEmptyArray(render_global, options.routes.len);
-    const route_output_indices = try allocator.alloc(OutputFile.Index, options.routes.len);
     var css_chunks_count: usize = 0;
     var css_chunks_first: usize = 0;
 
-    for (bundled_outputs.items, 0..) |file, i| {
-        // std.debug.print("{s} - {s} : {s} - {?d}\n", .{
-        //     if (file.side) |s| @tagName(s) else "null",
-        //     file.src_path.text,
-        //     file.dest_path,
-        //     file.entry_point_index,
-        // });
-        // std.debug.print("css: {d}\n", .{bun.fmt.fmtSlice(file.referenced_css_files, ", ")});
+    path_map.out_index_map = try allocator.alloc(u32, path_map.entry_points.items.len);
+    path_map.out_module_keys = try allocator.alloc(JSValue, bundled_outputs.len);
+    @memset(path_map.out_module_keys, .undefined);
+    const all_server_files = JSValue.createEmptyArray(global, bundled_outputs.len);
+
+    for (bundled_outputs, 0..) |file, i| {
+        log("{s} - {s} : {s} - {?d}\n", .{
+            if (file.side) |s| @tagName(s) else "null",
+            file.src_path.text,
+            file.dest_path,
+            file.entry_point_index,
+        });
         if (file.loader == .css) {
             if (css_chunks_count == 0) css_chunks_first = i;
             css_chunks_count += 1;
         }
+
+        if (file.entry_point_index) |entry_point| {
+            if (entry_point < path_map.out_index_map.len) {
+                path_map.out_index_map[entry_point] = @intCast(i);
+            }
+        }
+
         switch (file.side orelse .client) {
             .client => {
-                // client-side resources will be written to disk for usage in on the client side
+                // Client-side resources will be written to disk for usage in on the client side
                 _ = try file.writeToDisk(root_dir, root_dir_path);
-
-                if (file.entry_point_index) |entry_point| {
-                    switch (entry_point) {
-                        1 => client_entry_id = @intCast(i),
-                        else => {},
-                    }
-                }
             },
             .server => {
                 // For Debugging
@@ -258,42 +299,27 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
 
                 switch (file.output_kind) {
                     .@"entry-point", .chunk => {
-                        var buf: bun.PathBuffer = undefined;
+                        const without_prefix = if (bun.strings.hasPrefixComptime(file.dest_path, "./") or
+                            (Environment.isWindows and bun.strings.hasPrefixComptime(file.dest_path, ".\\")))
+                            file.dest_path[2..]
+                        else
+                            file.dest_path;
+
                         // TODO: later we can lazily register modules
                         const module_key = BakeRegisterProductionChunk(
-                            render_global,
-                            bun.String.createUTF8(bun.path.joinAbsStringBuf(cwd, &buf, &.{
-                                root_dir_path,
-                                file.dest_path,
-                            }, .auto)),
+                            global,
+                            try bun.String.createFormat("bake:/{s}", .{without_prefix}),
                             file.value.toBunString(),
                         ) catch |err| {
-                            vm.printErrorLikeObjectToConsole(render_global.takeException(err));
-                            if (vm.exit_handler.exit_code == 0) {
-                                vm.exit_handler.exit_code = 1;
-                            }
                             Output.errGeneric("could not load bundled chunk {} for server-side rendering", .{
-                                bun.fmt.quote(file.dest_path),
+                                bun.fmt.quote(without_prefix),
                             });
-                            vm.globalExit();
+                            return err;
                         };
-
-                        if (file.entry_point_index) |entry_point| {
-                            // classify the entry point. since entry point source indices are
-                            // deterministic, we can map every single one back to the route or
-                            // framework file.
-                            switch (entry_point) {
-                                0 => server_entry_module_key = module_key,
-                                1 => {}, // client entry
-                                else => |j| {
-                                    // SCBs are entry points past the two framework entry points
-                                    const route_index = j - 2;
-                                    if (route_index < options.routes.len) {
-                                        route_module_keys.putIndex(vm.global, route_index, module_key);
-                                        route_output_indices[route_index] = OutputFile.Index.init(@intCast(i));
-                                    }
-                                },
-                            }
+                        bun.assert(module_key.isString());
+                        if (file.entry_point_index != null) {
+                            path_map.out_module_keys[i] = module_key;
+                            all_server_files.putIndex(global, @intCast(i), module_key);
                         }
                     },
                     .asset => {},
@@ -304,63 +330,147 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
         }
     }
 
-    // TODO: umm...
-    // const primary_global = vm.global;
-    // vm.global = render_global;
-    // _ = primary_global;
-
-    bun.assert(client_entry_id != std.math.maxInt(u32));
-    bun.assert(server_entry_module_key != .undefined);
+    // Static site generator
+    const server_render_funcs = JSValue.createEmptyArray(global, router.types.len);
+    const client_entry_urls = JSValue.createEmptyArray(global, router.types.len);
+
+    for (router.types, 0..) |router_type, i| {
+        if (router_type.client_file.unwrap()) |client_file| {
+            const str = (try bun.String.createFormat("{s}{s}", .{
+                public_path,
+                bundled_outputs[path_map.getOutIndex(client_file)].dest_path,
+            })).toJS(global);
+            client_entry_urls.putIndex(global, @intCast(i), str);
+        } else {
+            client_entry_urls.putIndex(global, @intCast(i), .null);
+        }
 
-    // HACK: react-server-dom-webpack assigns to `__webpack_require__.u`
-    // We never call this in this context, so we will just make '__webpack_require__' an empty object.
-    // Right now server.tsx is what controls the value, but imports happen first.
-    render_global.toJSValue().put(render_global, "__webpack_require__", JSValue.createEmptyObject(render_global, 0));
+        const server_entry_module_key = path_map.out_module_keys[path_map.getOutIndex(router_type.server_file)];
+        bun.assert(server_entry_module_key != .undefined);
+        const server_entry_point = try loadModule(vm, global, server_entry_module_key);
+        const server_render_func = brk: {
+            const raw = BakeGetOnModuleNamespace(global, server_entry_point, "prerender") orelse
+                break :brk null;
+            if (!raw.isCallable(vm.jsc)) {
+                break :brk null;
+            }
+            break :brk raw;
+        } orelse {
+            Output.errGeneric("Framework does not support static site generation", .{});
+            Output.note("The file {s} is missing the \"prerender\" export, which defines how to generate static files.", .{
+                bun.fmt.quote(path_map.route_files.keys()[router_type.server_file.get()]),
+            });
+            bun.Global.crash();
+        };
+        server_render_funcs.putIndex(global, @intCast(i), server_render_func);
+    }
 
-    // Static site generator
-    const server_entry_point = loadModule(vm, render_global, server_entry_module_key);
-    const server_render_func: JSValue = BakeGetOnModuleNamespace(render_global, server_entry_point, "renderStatic") orelse {
-        Output.errGeneric("Framework does not support static site generation", .{});
-        Output.note("The file {s} is missing the \"renderStatic\" export", .{bun.fmt.quote(framework.entry_server)});
-        bun.Global.crash();
-    };
+    var navigatable_routes = std.ArrayList(FrameworkRouter.Route.Index).init(allocator);
+    for (router.routes.items, 0..) |route, i| {
+        _ = route.file_page.unwrap() orelse continue;
+        try navigatable_routes.append(FrameworkRouter.Route.Index.init(@intCast(i)));
+    }
 
-    const route_patterns = JSValue.createEmptyArray(render_global, options.routes.len);
-    const route_style_references = JSValue.createEmptyArray(render_global, options.routes.len);
     const css_chunk_js_strings = try allocator.alloc(JSValue, css_chunks_count);
-    for (bundled_outputs.items[css_chunks_first..][0..css_chunks_count], css_chunk_js_strings) |output_file, *str| {
+    for (bundled_outputs[css_chunks_first..][0..css_chunks_count], css_chunk_js_strings) |output_file, *str| {
         bun.assert(output_file.dest_path[0] != '.');
         bun.assert(output_file.loader == .css);
-        str.* = (try bun.String.createFormat("{s}{s}", .{ public_path, output_file.dest_path })).toJS(render_global);
+        str.* = (try bun.String.createFormat("{s}{s}", .{ public_path, output_file.dest_path })).toJS(global);
     }
 
-    for (
-        options.routes,
-        route_output_indices,
-        0..,
-    ) |route, output_file_i, i| {
-        route_patterns.putIndex(render_global, @intCast(i), bun.String.createUTF8(route.pattern).toJS(render_global));
-        const output_file = &bundled_outputs.items[output_file_i.get()];
-
-        const styles = JSValue.createEmptyArray(render_global, output_file.referenced_css_files.len);
-        for (output_file.referenced_css_files, 0..) |ref, j| {
-            styles.putIndex(render_global, @intCast(j), css_chunk_js_strings[ref.get() - css_chunks_first]);
+    const route_patterns = JSValue.createEmptyArray(global, navigatable_routes.items.len);
+    const route_nested_files = JSValue.createEmptyArray(global, navigatable_routes.items.len);
+    const route_type_and_flags = JSValue.createEmptyArray(global, navigatable_routes.items.len);
+    const route_source_files = JSValue.createEmptyArray(global, navigatable_routes.items.len);
+    const route_param_info = JSValue.createEmptyArray(global, navigatable_routes.items.len);
+    const route_style_references = JSValue.createEmptyArray(global, navigatable_routes.items.len);
+
+    var params_buf: std.ArrayListUnmanaged([]const u8) = .{};
+    for (navigatable_routes.items, 0..) |route_index, nav_index| {
+        defer params_buf.clearRetainingCapacity();
+
+        var pattern = bake.PatternBuffer.empty;
+
+        const route = router.routePtr(route_index);
+        const main_file_route_index = route.file_page.unwrap().?;
+        const main_file_index = path_map.getOutIndex(main_file_route_index);
+
+        pattern.prependPart(route.part);
+
+        var file_count: u32 = 1;
+        var css_file_count: u32 = @intCast(bundled_outputs[main_file_index].referenced_css_files.len);
+        if (route.file_layout.unwrap()) |file| {
+            css_file_count += @intCast(bundled_outputs[path_map.getOutIndex(file)].referenced_css_files.len);
+            file_count += 1;
         }
-        route_style_references.putIndex(render_global, @intCast(i), styles);
-    }
+        var next: ?FrameworkRouter.Route.Index = route.parent.unwrap();
+        while (next) |parent_index| {
+            const parent = router.routePtr(parent_index);
+            pattern.prependPart(parent.part);
+            if (parent.file_layout.unwrap()) |file| {
+                css_file_count += @intCast(bundled_outputs[path_map.getOutIndex(file)].referenced_css_files.len);
+                file_count += 1;
+            }
+            next = parent.parent.unwrap();
+        }
+        const styles = JSValue.createEmptyArray(global, css_chunks_count);
+        const file_list = JSValue.createEmptyArray(global, file_count);
+        next = route.parent.unwrap();
+        file_count = 1;
+        css_file_count = 0;
+        file_list.putIndex(global, 0, JSValue.jsNumberFromInt32(@intCast(main_file_route_index.get())));
+        for (bundled_outputs[main_file_index].referenced_css_files) |ref| {
+            styles.putIndex(global, css_file_count, css_chunk_js_strings[ref.get() - css_chunks_first]);
+            css_file_count += 1;
+        }
+        if (route.file_layout.unwrap()) |file| {
+            file_list.putIndex(global, file_count, JSValue.jsNumberFromInt32(@intCast(file.get())));
+            for (bundled_outputs[path_map.getOutIndex(file)].referenced_css_files) |ref| {
+                styles.putIndex(global, css_file_count, css_chunk_js_strings[ref.get() - css_chunks_first]);
+                css_file_count += 1;
+            }
+            file_count += 1;
+        }
+        while (next) |parent_index| {
+            const parent = router.routePtr(parent_index);
+            if (parent.file_layout.unwrap()) |file| {
+                file_list.putIndex(global, file_count, JSValue.jsNumberFromInt32(@intCast(file.get())));
+                for (bundled_outputs[path_map.getOutIndex(file)].referenced_css_files) |ref| {
+                    styles.putIndex(global, css_file_count, css_chunk_js_strings[ref.get() - css_chunks_first]);
+                    css_file_count += 1;
+                }
+                file_count += 1;
+            }
+            next = parent.parent.unwrap();
+        }
+
+        var pattern_string = bun.String.createUTF8(pattern.slice());
+        defer pattern_string.deref();
+        route_patterns.putIndex(global, @intCast(nav_index), pattern_string.toJS(global));
+
+        var src_path = bun.String.createUTF8(bun.path.relative(cwd, path_map.route_files.keys()[main_file_route_index.get()]));
+        route_source_files.putIndex(global, @intCast(nav_index), src_path.transferToJS(global));
 
-    const client_entry_url = (try bun.String.createFormat("{s}{s}", .{
-        public_path,
-        bundled_outputs.items[client_entry_id].dest_path,
-    })).toJS(render_global);
+        route_nested_files.putIndex(global, @intCast(nav_index), file_list);
+        route_type_and_flags.putIndex(global, @intCast(nav_index), JSValue.jsNumberFromInt32(@bitCast(TypeAndFlags{
+            .type = route.type.get(),
+        })));
+        route_param_info.putIndex(global, @intCast(nav_index), .null);
+        route_style_references.putIndex(global, @intCast(nav_index), styles);
+    }
 
-    const render_promise = BakeRenderRoutesForProd(
-        render_global,
+    const render_promise = BakeRenderRoutesForProdStatic(
+        global,
         bun.String.init(root_dir_path),
-        server_render_func,
-        client_entry_url,
-        route_module_keys,
+        all_server_files,
+        server_render_funcs,
+        client_entry_urls,
+
         route_patterns,
+        route_nested_files,
+        route_type_and_flags,
+        route_source_files,
+        route_param_info,
         route_style_references,
     );
     vm.waitForPromise(.{ .normal = render_promise });
@@ -371,18 +481,15 @@ pub fn buildCommand(ctx: bun.CLI.Command.Context) !void {
             Output.flush();
         },
         .rejected => |err| {
-            vm.printErrorLikeObjectToConsole(err);
-            if (vm.exit_handler.exit_code == 0) {
-                vm.exit_handler.exit_code = 1;
-            }
-            vm.globalExit();
+            vm.global.throwValue(err);
+            return error.JSError;
         },
     }
 }
 
 /// unsafe function, must be run outside of the event loop
 /// quits the process on exception
-fn loadModule(vm: *VirtualMachine, global: *JSC.JSGlobalObject, key: JSValue) JSValue {
+fn loadModule(vm: *VirtualMachine, global: *JSC.JSGlobalObject, key: JSValue) !JSValue {
     const promise = BakeLoadModuleByKey(global, key).asAnyPromise().?.internal;
     vm.waitForPromise(.{ .internal = promise });
     switch (promise.unwrap(vm.jsc, .mark_handled)) {
@@ -392,11 +499,8 @@ fn loadModule(vm: *VirtualMachine, global: *JSC.JSGlobalObject, key: JSValue) JS
             return BakeGetModuleNamespace(global, key);
         },
         .rejected => |err| {
-            vm.printErrorLikeObjectToConsole(err);
-            if (vm.exit_handler.exit_code == 0) {
-                vm.exit_handler.exit_code = 1;
-            }
-            vm.globalExit();
+            vm.global.throwValue(err);
+            return error.JSError;
         },
     }
 }
@@ -417,17 +521,21 @@ fn BakeGetOnModuleNamespace(global: *JSC.JSGlobalObject, module: JSValue, proper
     return result;
 }
 
-extern fn BakeRenderRoutesForProd(
+extern fn BakeRenderRoutesForProdStatic(
     *JSC.JSGlobalObject,
     out_base: bun.String,
-    render_static_cb: JSValue,
-    client_entry_url: JSValue,
-    arr: JSValue,
+    all_server_files: JSValue,
+    render_static: JSValue,
+    client_entry_urls: JSValue,
     patterns: JSValue,
+    files: JSValue,
+    type_and_flags: JSValue,
+    src_route_files: JSValue,
+    param_information: JSValue,
     styles: JSValue,
 ) *JSC.JSPromise;
 
-extern fn BakeCreateProdGlobal(vm: *JSC.VM, console_ptr: *anyopaque) *JSC.JSGlobalObject;
+extern fn BakeCreateProdGlobal(console_ptr: *anyopaque) *JSC.JSGlobalObject;
 
 /// The result of this function is a JSValue that wont be garbage collected, as
 /// it will always have at least one reference by the module loader.
@@ -441,7 +549,7 @@ fn BakeRegisterProductionChunk(global: *JSC.JSGlobalObject, key: bun.String, sou
     return result;
 }
 
-fn BakeProdResolve(global: *JSC.JSGlobalObject, a_str: bun.String, specifier_str: bun.String) callconv(.C) bun.String {
+export fn BakeProdResolve(global: *JSC.JSGlobalObject, a_str: bun.String, specifier_str: bun.String) callconv(.C) bun.String {
     var sfa = std.heap.stackFallback(@sizeOf(bun.PathBuffer) * 2, bun.default_allocator);
     const alloc = sfa.get();
 
@@ -463,27 +571,76 @@ fn BakeProdResolve(global: *JSC.JSGlobalObject, a_str: bun.String, specifier_str
         return bun.String.dead;
     }
 
-    return bun.String.createUTF8(bun.path.joinAbs(
-        bun.Dirname.dirname(u8, referrer.slice()) orelse referrer.slice(),
+    if (Environment.allow_assert)
+        bun.assert(bun.strings.hasPrefix(referrer.slice(), "bake:"));
+
+    return bun.String.createFormat("bake:{s}", .{bun.path.joinAbs(
+        bun.Dirname.dirname(u8, referrer.slice()[5..]) orelse referrer.slice()[5..],
         .auto,
         specifier.slice(),
-    ));
+    )}) catch return bun.String.dead;
 }
 
-comptime {
-    if (bun.FeatureFlags.bake)
-        @export(BakeProdResolve, .{ .name = "BakeProdResolve" });
-}
+/// Tracks all entry points for a production bundle
+const ProductionPathMap = struct {
+    allocator: std.mem.Allocator,
+
+    entry_points: std.ArrayListUnmanaged(BakeEntryPoint),
+    route_files: bun.StringArrayHashMapUnmanaged(void),
+    /// OpaqueFileId -> index into output_files
+    out_index_map: []u32,
+    /// index into output_files -> key to load them in JavaScript
+    out_module_keys: []JSValue,
+
+    const RouteType = struct {
+        client_file: FrameworkRouter.OpaqueFileId.Optional,
+        server_file: FrameworkRouter.OpaqueFileId,
+    };
+
+    fn getOutIndex(ppm: *ProductionPathMap, index: FrameworkRouter.OpaqueFileId) u32 {
+        return ppm.out_index_map[index.get()];
+    }
+
+    pub fn getFileIdForRouter(ctx: *ProductionPathMap, abs_path: []const u8, _: FrameworkRouter.Route.Index, _: FrameworkRouter.Route.FileKind) !FrameworkRouter.OpaqueFileId {
+        const gop = try ctx.route_files.getOrPut(ctx.allocator, abs_path);
+        if (!gop.found_existing) {
+            const dupe = try ctx.allocator.dupe(u8, abs_path);
+            try ctx.entry_points.append(ctx.allocator, BakeEntryPoint.init(dupe, .server));
+            gop.key_ptr.* = dupe;
+            gop.value_ptr.* = {};
+        }
+        return FrameworkRouter.OpaqueFileId.init(@intCast(gop.index));
+    }
+
+    pub fn getClientFile(ctx: *ProductionPathMap, abs_path: []const u8) !FrameworkRouter.OpaqueFileId {
+        // Bug: if server and client reference the same file, it is impossible to know which side it was already queued for, leading to a missing output file.
+        const gop = try ctx.route_files.getOrPut(ctx.allocator, abs_path);
+        if (!gop.found_existing) {
+            const dupe = try ctx.allocator.dupe(u8, abs_path);
+            try ctx.entry_points.append(ctx.allocator, BakeEntryPoint.initClientWrapped(dupe, .client));
+            gop.key_ptr.* = dupe;
+            gop.value_ptr.* = {};
+        }
+        return FrameworkRouter.OpaqueFileId.init(@intCast(gop.index));
+    }
+};
+
+const TypeAndFlags = packed struct(i32) {
+    type: u8,
+    unused: u24 = 0,
+};
 
 const std = @import("std");
 
 const bun = @import("root").bun;
-const bake = bun.bake;
 const Environment = bun.Environment;
 const Output = bun.Output;
 const BakeEntryPoint = bun.bundle_v2.BakeEntryPoint;
 const OutputFile = bun.options.OutputFile;
 
+const bake = bun.bake;
+const FrameworkRouter = bake.FrameworkRouter;
+
 const JSC = bun.JSC;
 const JSValue = JSC.JSValue;
 const VirtualMachine = JSC.VirtualMachine;
diff --git a/src/bake/tsconfig.json b/src/bake/tsconfig.json
index 7fbb53f3f89d9f..81f1f16c3a66df 100644
--- a/src/bake/tsconfig.json
+++ b/src/bake/tsconfig.json
@@ -12,10 +12,11 @@
     "downlevelIteration": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "jsx": "react",
     "paths": {
-      "bun-framework-rsc/*": ["./bun-framework-rsc/*"]
-    }
+      "bun-framework-react/*": ["./bun-framework-react/*"]
+    },
+    "jsx": "react-jsx",
+    "types": ["react/experimental"]
   },
   "include": ["**/*.ts", "**/*.tsx"]
 }
diff --git a/src/bun.js/BuildMessage.zig b/src/bun.js/BuildMessage.zig
index e3952df4c90bb4..f27f98e230769e 100644
--- a/src/bun.js/BuildMessage.zig
+++ b/src/bun.js/BuildMessage.zig
@@ -19,12 +19,8 @@ pub const BuildMessage = struct {
 
     pub usingnamespace JSC.Codegen.JSBuildMessage;
 
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        _: *JSC.CallFrame,
-    ) ?*BuildMessage {
-        globalThis.throw("BuildMessage is not constructable", .{});
-        return null;
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*BuildMessage {
+        return globalThis.throw2("BuildMessage is not constructable", .{});
     }
 
     pub fn getNotes(this: *BuildMessage, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
@@ -81,7 +77,7 @@ pub const BuildMessage = struct {
         this: *BuildMessage,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.toStringFn(globalThis);
     }
 
@@ -89,7 +85,7 @@ pub const BuildMessage = struct {
         this: *BuildMessage,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const args_ = callframe.arguments(1);
         const args = args_.ptr[0..args_.len];
         if (args.len > 0) {
@@ -110,7 +106,7 @@ pub const BuildMessage = struct {
         this: *BuildMessage,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var object = JSC.JSValue.createEmptyObject(globalThis, 4);
         object.put(globalThis, ZigString.static("name"), bun.String.static("BuildMessage").toJS(globalThis));
         object.put(globalThis, ZigString.static("position"), this.getPosition(globalThis));
diff --git a/src/bun.js/ConsoleObject.zig b/src/bun.js/ConsoleObject.zig
index 69548626234a86..03f9ac1a851966 100644
--- a/src/bun.js/ConsoleObject.zig
+++ b/src/bun.js/ConsoleObject.zig
@@ -453,7 +453,7 @@ pub const TablePrinter = struct {
                 value = row_value.getOwn(this.globalObject, col.name) orelse JSValue.zero;
             }
 
-            if (value.isEmpty()) {
+            if (value == .zero) {
                 try writer.writeByteNTimes(' ', col.width + (PADDING * 2));
             } else {
                 const len: u32 = this.getWidthForValue(value);
@@ -683,11 +683,11 @@ pub const FormatOptions = struct {
     single_line: bool = false,
     default_indent: u16 = 0,
 
-    pub fn fromJS(formatOptions: *FormatOptions, globalThis: *JSC.JSGlobalObject, arguments: []const JSC.JSValue) !void {
+    pub fn fromJS(formatOptions: *FormatOptions, globalThis: *JSC.JSGlobalObject, arguments: []const JSC.JSValue) bun.JSError!void {
         const arg1 = arguments[0];
 
         if (arg1.isObject()) {
-            if (arg1.getTruthy(globalThis, "depth")) |opt| {
+            if (try arg1.getTruthy(globalThis, "depth")) |opt| {
                 if (opt.isInt32()) {
                     const arg = opt.toInt32();
                     if (arg < 0) {
@@ -705,14 +705,14 @@ pub const FormatOptions = struct {
                     }
                 }
             }
-            if (try arg1.getOptional(globalThis, "colors", bool)) |opt| {
+            if (try arg1.getBooleanLoose(globalThis, "colors")) |opt| {
                 formatOptions.enable_colors = opt;
             }
-            if (try arg1.getOptional(globalThis, "sorted", bool)) |opt| {
+            if (try arg1.getBooleanLoose(globalThis, "sorted")) |opt| {
                 formatOptions.ordered_properties = opt;
             }
 
-            if (try arg1.getOptional(globalThis, "compact", bool)) |opt| {
+            if (try arg1.getBooleanLoose(globalThis, "compact")) |opt| {
                 formatOptions.single_line = opt;
             }
         } else {
@@ -972,7 +972,7 @@ pub const Formatter = struct {
     // For detecting circular references
     pub const Visited = struct {
         const ObjectPool = @import("../pool.zig").ObjectPool;
-        pub const Map = std.AutoHashMap(JSValue.Type, void);
+        pub const Map = std.AutoHashMap(JSValue, void);
         pub const Pool = ObjectPool(
             Map,
             struct {
@@ -1662,8 +1662,8 @@ pub const Formatter = struct {
                     this.writer.writeAll(" ") catch unreachable;
                 }
                 if (!is_iterator) {
-                    const key = JSC.JSObject.getIndex(nextValue, globalObject, 0);
-                    const value = JSC.JSObject.getIndex(nextValue, globalObject, 1);
+                    const key = nextValue.getIndex(globalObject, 0);
+                    const value = nextValue.getIndex(globalObject, 1);
 
                     if (!single_line) {
                         this.formatter.writeIndent(Writer, this.writer) catch unreachable;
@@ -1949,7 +1949,7 @@ pub const Formatter = struct {
                 this.map = this.map_node.?.data;
             }
 
-            const entry = this.map.getOrPut(@intFromEnum(value)) catch unreachable;
+            const entry = this.map.getOrPut(value) catch unreachable;
             if (entry.found_existing) {
                 writer.writeAll(comptime Output.prettyFmt("<r><cyan>[Circular]<r>", enable_ansi_colors));
                 return;
@@ -1958,7 +1958,7 @@ pub const Formatter = struct {
 
         defer {
             if (comptime Format.canHaveCircularReferences()) {
-                _ = this.map.remove(@intFromEnum(value));
+                _ = this.map.remove(value);
             }
         }
 
@@ -2259,7 +2259,7 @@ pub const Formatter = struct {
                             this.addForNewLine(2);
                         }
 
-                        if (element.isEmpty()) {
+                        if (element == .zero) {
                             empty_start = 0;
                             break :first;
                         }
@@ -2278,7 +2278,7 @@ pub const Formatter = struct {
 
                     while (i < len) : (i += 1) {
                         const element = value.getDirectIndex(this.globalThis, i);
-                        if (element.isEmpty()) {
+                        if (element == .zero) {
                             if (empty_start == null) {
                                 empty_start = i;
                             }
@@ -3001,7 +3001,7 @@ pub const Formatter = struct {
 
                                                 var j: usize = 0;
                                                 while (j < length) : (j += 1) {
-                                                    const child = JSC.JSObject.getIndex(children, this.globalThis, @as(u32, @intCast(j)));
+                                                    const child = children.getIndex(this.globalThis, @as(u32, @intCast(j)));
                                                     this.format(Tag.getAdvanced(child, this.globalThis, .{ .hide_global = true }), Writer, writer_, child, this.globalThis, enable_ansi_colors);
                                                     if (j + 1 < length) {
                                                         writer.writeAll("\n");
diff --git a/src/bun.js/ResolveMessage.zig b/src/bun.js/ResolveMessage.zig
index 0eddbfd9dbd3bb..3a3313f7ecb431 100644
--- a/src/bun.js/ResolveMessage.zig
+++ b/src/bun.js/ResolveMessage.zig
@@ -18,12 +18,8 @@ pub const ResolveMessage = struct {
 
     pub usingnamespace JSC.Codegen.JSResolveMessage;
 
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        _: *JSC.CallFrame,
-    ) ?*ResolveMessage {
-        globalThis.throw("ResolveMessage is not constructable", .{});
-        return null;
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*ResolveMessage {
+        return globalThis.throw2("ResolveMessage is not constructable", .{});
     }
 
     pub fn getCode(this: *ResolveMessage, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
@@ -111,7 +107,7 @@ pub const ResolveMessage = struct {
         this: *ResolveMessage,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.toStringFn(globalThis);
     }
 
@@ -119,7 +115,7 @@ pub const ResolveMessage = struct {
         this: *ResolveMessage,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const args_ = callframe.arguments(1);
         const args = args_.ptr[0..args_.len];
         if (args.len > 0) {
@@ -140,7 +136,7 @@ pub const ResolveMessage = struct {
         this: *ResolveMessage,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var object = JSC.JSValue.createEmptyObject(globalThis, 7);
         object.put(globalThis, ZigString.static("name"), bun.String.static("ResolveMessage").toJS(globalThis));
         object.put(globalThis, ZigString.static("position"), this.getPosition(globalThis));
diff --git a/src/bun.js/RuntimeTranspilerCache.zig b/src/bun.js/RuntimeTranspilerCache.zig
index adcf0542bdf64a..ca1c9cb1c87930 100644
--- a/src/bun.js/RuntimeTranspilerCache.zig
+++ b/src/bun.js/RuntimeTranspilerCache.zig
@@ -5,7 +5,9 @@
 /// Version 6: `use strict` is preserved in CommonJS modules when at the top of the file
 /// Version 7: Several bundler changes that are likely to impact the runtime as well.
 /// Version 8: Fix for generated symbols
-const expected_version = 8;
+/// Version 9: String printing changes
+/// Version 10: Constant folding for ''.charCodeAt(n)
+const expected_version = 10;
 
 const bun = @import("root").bun;
 const std = @import("std");
diff --git a/src/bun.js/api/BunObject.zig b/src/bun.js/api/BunObject.zig
index bef890cb65d280..4347c0721633a7 100644
--- a/src/bun.js/api/BunObject.zig
+++ b/src/bun.js/api/BunObject.zig
@@ -12,7 +12,7 @@ pub const BunObject = struct {
     pub const allocUnsafe = toJSCallback(Bun.allocUnsafe);
     pub const braces = toJSCallback(Bun.braces);
     pub const build = toJSCallback(Bun.JSBundler.buildFn);
-    pub const color = bun.css.CssColor.jsFunctionColor;
+    pub const color = toJSCallback(bun.css.CssColor.jsFunctionColor);
     pub const connect = toJSCallback(JSC.wrapStaticMethod(JSC.API.Listener, "connect", false));
     pub const createParsedShellScript = toJSCallback(bun.shell.ParsedShellScript.createParsedShellScript);
     pub const createShellInterpreter = toJSCallback(bun.shell.Interpreter.createShellInterpreter);
@@ -85,11 +85,11 @@ pub const BunObject = struct {
 
     const toJSCallback = JSC.toJSHostFunction;
 
-    const LazyPropertyCallback = fn (*JSC.JSGlobalObject, *JSC.JSObject) callconv(JSC.conv) JSC.JSValue;
+    const LazyPropertyCallback = fn (*JSC.JSGlobalObject, *JSC.JSObject) callconv(JSC.conv) JSValue;
 
     fn toJSGetter(comptime getter: anytype) LazyPropertyCallback {
         return struct {
-            pub fn callback(this: *JSC.JSGlobalObject, object: *JSC.JSObject) callconv(JSC.conv) JSC.JSValue {
+            pub fn callback(this: *JSC.JSGlobalObject, object: *JSC.JSObject) callconv(JSC.conv) JSValue {
                 return @call(.always_inline, getter, .{ this, object });
             }
         }.callback;
@@ -262,7 +262,7 @@ const Shell = @import("../../shell/shell.zig");
 pub fn shellEscape(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1);
     if (arguments.len < 1) {
         globalThis.throw("shell escape expected at least 1 argument", .{});
@@ -296,7 +296,7 @@ pub fn shellEscape(
 pub fn braces(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments_ = callframe.arguments(2);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     defer arguments.deinit();
@@ -317,11 +317,11 @@ pub fn braces(
     if (arguments.nextEat()) |opts_val| {
         if (opts_val.isObject()) {
             if (comptime bun.Environment.allow_assert) {
-                if (opts_val.getTruthy(globalThis, "tokenize")) |tokenize_val| {
+                if (try opts_val.getTruthy(globalThis, "tokenize")) |tokenize_val| {
                     tokenize = if (tokenize_val.isBoolean()) tokenize_val.asBoolean() else false;
                 }
 
-                if (opts_val.getTruthy(globalThis, "parse")) |tokenize_val| {
+                if (try opts_val.getTruthy(globalThis, "parse")) |tokenize_val| {
                     parse = if (tokenize_val.isBoolean()) tokenize_val.asBoolean() else false;
                 }
             }
@@ -403,7 +403,7 @@ pub fn braces(
 pub fn which(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments_ = callframe.arguments(2);
     var path_buf: bun.PathBuffer = undefined;
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
@@ -474,7 +474,7 @@ pub fn which(
 pub fn inspectTable(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) callconv(JSC.conv) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     var args_buf = callframe.argumentsUndef(5);
     var all_arguments = args_buf.mut();
     if (all_arguments[0].isUndefined() or all_arguments[0].isNull())
@@ -506,7 +506,7 @@ pub fn inspectTable(
         .single_line = true,
     };
     if (arguments[2].isObject()) {
-        formatOptions.fromJS(globalThis, arguments[2..]) catch return .zero;
+        try formatOptions.fromJS(globalThis, arguments[2..]);
     }
     const value = arguments[0];
 
@@ -549,7 +549,7 @@ pub fn inspectTable(
 pub fn inspect(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(4).slice();
     if (arguments.len == 0)
         return bun.String.empty.toJS(globalThis);
@@ -572,7 +572,7 @@ pub fn inspect(
         .ordered_properties = false,
     };
     if (arguments.len > 1) {
-        formatOptions.fromJS(globalThis, arguments[1..]) catch return .zero;
+        try formatOptions.fromJS(globalThis, arguments[1..]);
     }
     const value = arguments[0];
 
@@ -618,7 +618,7 @@ pub fn getInspect(globalObject: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSVal
 pub fn registerMacro(
     globalObject: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments_ = callframe.arguments(2);
     const arguments = arguments_.slice();
     if (arguments.len != 2 or !arguments[0].isNumber()) {
@@ -775,7 +775,7 @@ const Editor = @import("../../open.zig").Editor;
 pub fn openInEditor(
     globalThis: js.JSContextRef,
     callframe: *JSC.CallFrame,
-) JSValue {
+) bun.JSError!JSValue {
     var edit = &VirtualMachine.get().rareData().editor_context;
     const args = callframe.arguments(4);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), args.slice());
@@ -791,7 +791,7 @@ pub fn openInEditor(
 
     if (arguments.nextEat()) |opts| {
         if (!opts.isUndefinedOrNull()) {
-            if (opts.getTruthy(globalThis, "editor")) |editor_val| {
+            if (try opts.getTruthy(globalThis, "editor")) |editor_val| {
                 var sliced = editor_val.toSlice(globalThis, arguments.arena.allocator());
                 const prev_name = edit.name;
 
@@ -811,11 +811,11 @@ pub fn openInEditor(
                 }
             }
 
-            if (opts.getTruthy(globalThis, "line")) |line_| {
+            if (try opts.getTruthy(globalThis, "line")) |line_| {
                 line = line_.toSlice(globalThis, arguments.arena.allocator()).slice();
             }
 
-            if (opts.getTruthy(globalThis, "column")) |column_| {
+            if (try opts.getTruthy(globalThis, "column")) |column_| {
                 column = column_.toSlice(globalThis, arguments.arena.allocator()).slice();
             }
         }
@@ -893,14 +893,13 @@ pub fn getPublicPathWithAssetPrefix(
     }
 }
 
-pub fn sleepSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn sleepSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1);
 
     // Expect at least one argument.  We allow more than one but ignore them; this
     //  is useful for supporting things like `[1, 2].map(sleepSync)`
     if (arguments.len < 1) {
-        globalObject.throwNotEnoughArguments("sleepSync", 1, 0);
-        return .undefined;
+        return globalObject.throwNotEnoughArguments("sleepSync", 1, 0);
     }
     const arg = arguments.slice()[0];
 
@@ -921,16 +920,17 @@ pub fn sleepSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) J
     return .undefined;
 }
 
-pub fn generateHeapSnapshot(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+pub fn generateHeapSnapshot(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     return globalObject.generateHeapSnapshot();
 }
 
-pub fn runGC(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn runGC(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments_ = callframe.arguments(1);
     const arguments = arguments_.slice();
     return globalObject.bunVM().garbageCollect(arguments.len > 0 and arguments[0].isBoolean() and arguments[0].toBoolean());
 }
-pub fn shrink(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+
+pub fn shrink(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     globalObject.vm().shrinkFootprint();
     return .undefined;
 }
@@ -938,28 +938,27 @@ pub fn shrink(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue
 fn doResolve(
     globalThis: *JSC.JSGlobalObject,
     arguments: []const JSValue,
-    exception: js.ExceptionRef,
-) ?JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments);
     defer args.deinit();
     const specifier = args.protectEatNext() orelse {
-        JSC.throwInvalidArguments("Expected a specifier and a from path", .{}, globalThis, exception);
-        return null;
+        globalThis.throwInvalidArguments("Expected a specifier and a from path", .{});
+        return error.JSError;
     };
 
     if (specifier.isUndefinedOrNull()) {
-        JSC.throwInvalidArguments("specifier must be a string", .{}, globalThis, exception);
-        return null;
+        globalThis.throwInvalidArguments("specifier must be a string", .{});
+        return error.JSError;
     }
 
     const from = args.protectEatNext() orelse {
-        JSC.throwInvalidArguments("Expected a from path", .{}, globalThis, exception);
-        return null;
+        globalThis.throwInvalidArguments("Expected a from path", .{});
+        return error.JSError;
     };
 
     if (from.isUndefinedOrNull()) {
-        JSC.throwInvalidArguments("from must be a string", .{}, globalThis, exception);
-        return null;
+        globalThis.throwInvalidArguments("from must be a string", .{});
+        return error.JSError;
     }
 
     var is_esm = true;
@@ -967,8 +966,8 @@ fn doResolve(
         if (next.isBoolean()) {
             is_esm = next.toBoolean();
         } else {
-            JSC.throwInvalidArguments("esm must be a boolean", .{}, globalThis, exception);
-            return null;
+            globalThis.throwInvalidArguments("esm must be a boolean", .{});
+            return error.JSError;
         }
     }
 
@@ -980,7 +979,6 @@ fn doResolve(
         globalThis,
         specifier_str,
         from_str,
-        exception,
         is_esm,
         false,
     );
@@ -990,10 +988,9 @@ fn doResolveWithArgs(
     ctx: js.JSContextRef,
     specifier: bun.String,
     from: bun.String,
-    exception: js.ExceptionRef,
     is_esm: bool,
     comptime is_file_path: bool,
-) ?JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     var errorable: ErrorableString = undefined;
     var query_string = ZigString.Empty;
 
@@ -1006,7 +1003,7 @@ fn doResolveWithArgs(
     if (comptime is_file_path) {
         VirtualMachine.resolveFilePathForAPI(
             &errorable,
-            ctx.ptr(),
+            ctx,
             specifier_decoded,
             from,
             &query_string,
@@ -1015,7 +1012,7 @@ fn doResolveWithArgs(
     } else {
         VirtualMachine.resolveForAPI(
             &errorable,
-            ctx.ptr(),
+            ctx,
             specifier_decoded,
             from,
             &query_string,
@@ -1024,8 +1021,8 @@ fn doResolveWithArgs(
     }
 
     if (!errorable.success) {
-        exception.* = bun.cast(JSC.JSValueRef, errorable.result.err.ptr.?);
-        return null;
+        ctx.throwValue(bun.cast(JSC.JSValueRef, errorable.result.err.ptr.?).?.value());
+        return error.JSError;
     }
 
     if (query_string.len > 0) {
@@ -1037,9 +1034,8 @@ fn doResolveWithArgs(
             errorable.result.value,
             query_string,
         }) catch {
-            // TODO: binding for createOutOfMemoryError
-            exception.* = JSC.createError(ctx, "Out of memory", .{}).asObjectRef();
-            return null;
+            ctx.throwOutOfMemory();
+            return error.JSError;
         };
 
         return ZigString.initUTF8(arraylist.items).toJS(ctx);
@@ -1048,25 +1044,16 @@ fn doResolveWithArgs(
     return errorable.result.value.toJS(ctx);
 }
 
-pub fn resolveSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
-    const exception = &exception_;
+pub fn resolveSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(3);
-    const result = doResolve(globalObject, arguments.slice(), exception);
-
-    if (exception_[0] != null) {
-        globalObject.throwValue(exception_[0].?.value());
-    }
-
-    return result orelse .zero;
+    return try doResolve(globalObject, arguments.slice());
 }
 
-pub fn resolve(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
-    const exception = &exception_;
+pub fn resolve(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(3);
-    const value = doResolve(globalObject, arguments.slice(), exception) orelse {
-        return JSC.JSPromise.rejectedPromiseValue(globalObject, exception_[0].?.value());
+    const value = doResolve(globalObject, arguments.slice()) catch {
+        const err = globalObject.tryTakeException().?;
+        return JSC.JSPromise.rejectedPromiseValue(globalObject, err);
     };
     return JSC.JSPromise.resolvedPromiseValue(globalObject, value);
 }
@@ -1077,16 +1064,15 @@ export fn Bun__resolve(
     source: JSValue,
     is_esm: bool,
 ) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
-    const exception = &exception_;
     const specifier_str = specifier.toBunString(global);
     defer specifier_str.deref();
 
     const source_str = source.toBunString(global);
     defer source_str.deref();
 
-    const value = doResolveWithArgs(global, specifier_str, source_str, exception, is_esm, true) orelse {
-        return JSC.JSPromise.rejectedPromiseValue(global, exception_[0].?.value());
+    const value = doResolveWithArgs(global, specifier_str, source_str, is_esm, true) catch {
+        const err = global.tryTakeException().?;
+        return JSC.JSPromise.rejectedPromiseValue(global, err);
     };
 
     return JSC.JSPromise.resolvedPromiseValue(global, value);
@@ -1098,18 +1084,13 @@ export fn Bun__resolveSync(
     source: JSValue,
     is_esm: bool,
 ) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
-    const exception = &exception_;
-
     const specifier_str = specifier.toBunString(global);
     defer specifier_str.deref();
 
     const source_str = source.toBunString(global);
     defer source_str.deref();
 
-    return doResolveWithArgs(global, specifier_str, source_str, exception, is_esm, true) orelse {
-        return JSC.JSValue.fromRef(exception[0]);
-    };
+    return JSC.toJSHostValue(global, doResolveWithArgs(global, specifier_str, source_str, is_esm, true));
 }
 
 export fn Bun__resolveSyncWithStrings(
@@ -1119,10 +1100,7 @@ export fn Bun__resolveSyncWithStrings(
     is_esm: bool,
 ) JSC.JSValue {
     Output.scoped(.importMetaResolve, false)("source: {s}, specifier: {s}", .{ source.*, specifier.* });
-    var exception = [1]JSC.JSValueRef{null};
-    return doResolveWithArgs(global, specifier.*, source.*, &exception, is_esm, true) orelse {
-        return JSC.JSValue.fromRef(exception[0]);
-    };
+    return JSC.toJSHostValue(global, doResolveWithArgs(global, specifier.*, source.*, is_esm, true));
 }
 
 export fn Bun__resolveSyncWithSource(
@@ -1131,19 +1109,14 @@ export fn Bun__resolveSyncWithSource(
     source: *bun.String,
     is_esm: bool,
 ) JSC.JSValue {
-    var exception_ = [1]JSC.JSValueRef{null};
     const specifier_str = specifier.toBunString(global);
     defer specifier_str.deref();
-
-    const exception = &exception_;
-    return doResolveWithArgs(global, specifier_str, source.*, exception, is_esm, true) orelse {
-        return JSC.JSValue.fromRef(exception[0]);
-    };
+    return JSC.toJSHostValue(global, doResolveWithArgs(global, specifier_str, source.*, is_esm, true));
 }
 
 extern fn dump_zone_malloc_stats() void;
 
-fn dump_mimalloc(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+fn dump_mimalloc(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     globalObject.bunVM().arena.dumpStats();
     if (bun.heap_breakdown.enabled) {
         dump_zone_malloc_stats();
@@ -1151,7 +1124,7 @@ fn dump_mimalloc(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSVal
     return .undefined;
 }
 
-pub fn indexOfLine(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn indexOfLine(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments_ = callframe.arguments(2);
     const arguments = arguments_.slice();
     if (arguments.len == 0) {
@@ -1515,46 +1488,45 @@ pub const Crypto = struct {
                 this.salt.deinit();
             }
 
-            pub fn fromJS(globalThis: *JSC.JSGlobalObject, arguments: []const JSC.JSValue, is_async: bool) ?PBKDF2 {
+            pub fn fromJS(globalThis: *JSC.JSGlobalObject, arguments: []const JSC.JSValue, is_async: bool) bun.JSError!PBKDF2 {
                 if (arguments.len < 5) {
-                    globalThis.throwNotEnoughArguments("pbkdf2", 5, arguments.len);
-                    return null;
+                    return globalThis.throwNotEnoughArguments("pbkdf2", 5, arguments.len);
                 }
 
                 if (!arguments[3].isAnyInt()) {
                     _ = globalThis.throwInvalidArgumentTypeValue("keylen", "integer", arguments[3]);
-                    return null;
+                    return error.JSError;
                 }
 
                 const length = arguments[3].coerce(i64, globalThis);
 
                 if (!globalThis.hasException() and (length < 0 or length > std.math.maxInt(i32))) {
-                    globalThis.throwInvalidArguments("keylen must be > 0 and < {d}", .{std.math.maxInt(i32)});
+                    return globalThis.throwInvalidArguments2("keylen must be > 0 and < {d}", .{std.math.maxInt(i32)});
                 }
 
                 if (globalThis.hasException()) {
-                    return null;
+                    return error.JSError;
                 }
 
                 if (!arguments[2].isAnyInt()) {
                     _ = globalThis.throwInvalidArgumentTypeValue("iteration count", "integer", arguments[2]);
-                    return null;
+                    return error.JSError;
                 }
 
                 const iteration_count = arguments[2].coerce(i64, globalThis);
 
                 if (!globalThis.hasException() and (iteration_count < 1 or iteration_count > std.math.maxInt(u32))) {
-                    globalThis.throwInvalidArguments("iteration count must be >= 1 and <= maxInt", .{});
+                    return globalThis.throwInvalidArguments2("iteration count must be >= 1 and <= maxInt", .{});
                 }
 
                 if (globalThis.hasException()) {
-                    return null;
+                    return error.JSError;
                 }
 
                 const algorithm = brk: {
                     if (!arguments[4].isString()) {
                         _ = globalThis.throwInvalidArgumentTypeValue("algorithm", "string", arguments[4]);
-                        return null;
+                        return error.JSError;
                     }
 
                     break :brk EVP.Algorithm.map.fromJSCaseInsensitive(globalThis, arguments[4]) orelse {
@@ -1564,7 +1536,7 @@ pub const Crypto = struct {
                             const name = slice.slice();
                             globalThis.ERR_CRYPTO_INVALID_DIGEST("Unsupported algorithm \"{s}\"", .{name}).throw();
                         }
-                        return null;
+                        return error.JSError;
                     };
                 };
 
@@ -1584,24 +1556,22 @@ pub const Crypto = struct {
 
                 out.salt = JSC.Node.StringOrBuffer.fromJSMaybeAsync(globalThis, bun.default_allocator, arguments[1], is_async) orelse {
                     _ = globalThis.throwInvalidArgumentTypeValue("salt", "string or buffer", arguments[1]);
-                    return null;
+                    return error.JSError;
                 };
 
                 if (out.salt.slice().len > std.math.maxInt(i32)) {
-                    globalThis.throwInvalidArguments("salt is too long", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("salt is too long", .{});
                 }
 
                 out.password = JSC.Node.StringOrBuffer.fromJSMaybeAsync(globalThis, bun.default_allocator, arguments[0], is_async) orelse {
                     if (!globalThis.hasException()) {
                         _ = globalThis.throwInvalidArgumentTypeValue("password", "string or buffer", arguments[0]);
                     }
-                    return null;
+                    return error.JSError;
                 };
 
                 if (out.password.slice().len > std.math.maxInt(i32)) {
-                    globalThis.throwInvalidArguments("password is too long", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("password is too long", .{});
                 }
 
                 return out;
@@ -1722,36 +1692,35 @@ pub const Crypto = struct {
                     .argon2id = .{},
                 };
 
-                pub fn fromJS(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) ?Value {
+                pub fn fromJS(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) bun.JSError!Value {
                     if (value.isObject()) {
-                        if (value.getTruthy(globalObject, "algorithm")) |algorithm_value| {
+                        if (try value.getTruthy(globalObject, "algorithm")) |algorithm_value| {
                             if (!algorithm_value.isString()) {
                                 globalObject.throwInvalidArgumentType("hash", "algorithm", "string");
-                                return null;
+                                return error.JSError;
                             }
 
                             const algorithm_string = algorithm_value.getZigString(globalObject);
 
                             switch (PasswordObject.Algorithm.label.getWithEql(algorithm_string, JSC.ZigString.eqlComptime) orelse {
                                 globalObject.throwInvalidArgumentType("hash", "algorithm", unknown_password_algorithm_message);
-                                return null;
+                                return error.JSError;
                             }) {
                                 .bcrypt => {
                                     var algorithm = PasswordObject.Algorithm.Value{
                                         .bcrypt = PasswordObject.Algorithm.Value.bcrpyt_default,
                                     };
 
-                                    if (value.getTruthy(globalObject, "cost")) |rounds_value| {
+                                    if (try value.getTruthy(globalObject, "cost")) |rounds_value| {
                                         if (!rounds_value.isNumber()) {
                                             globalObject.throwInvalidArgumentType("hash", "cost", "number");
-                                            return null;
+                                            return error.JSError;
                                         }
 
                                         const rounds = rounds_value.coerce(i32, globalObject);
 
                                         if (rounds < 4 or rounds > 31) {
-                                            globalObject.throwInvalidArguments("Rounds must be between 4 and 31", .{});
-                                            return null;
+                                            return globalObject.throwInvalidArguments2("Rounds must be between 4 and 31", .{});
                                         }
 
                                         algorithm.bcrypt = @as(u6, @intCast(rounds));
@@ -1762,33 +1731,31 @@ pub const Crypto = struct {
                                 inline .argon2id, .argon2d, .argon2i => |tag| {
                                     var argon = Algorithm.Argon2Params{};
 
-                                    if (value.getTruthy(globalObject, "timeCost")) |time_value| {
+                                    if (try value.getTruthy(globalObject, "timeCost")) |time_value| {
                                         if (!time_value.isNumber()) {
                                             globalObject.throwInvalidArgumentType("hash", "timeCost", "number");
-                                            return null;
+                                            return error.JSError;
                                         }
 
                                         const time_cost = time_value.coerce(i32, globalObject);
 
                                         if (time_cost < 1) {
-                                            globalObject.throwInvalidArguments("Time cost must be greater than 0", .{});
-                                            return null;
+                                            return globalObject.throwInvalidArguments2("Time cost must be greater than 0", .{});
                                         }
 
                                         argon.time_cost = @as(u32, @intCast(time_cost));
                                     }
 
-                                    if (value.getTruthy(globalObject, "memoryCost")) |memory_value| {
+                                    if (try value.getTruthy(globalObject, "memoryCost")) |memory_value| {
                                         if (!memory_value.isNumber()) {
                                             globalObject.throwInvalidArgumentType("hash", "memoryCost", "number");
-                                            return null;
+                                            return error.JSError;
                                         }
 
                                         const memory_cost = memory_value.coerce(i32, globalObject);
 
                                         if (memory_cost < 1) {
-                                            globalObject.throwInvalidArguments("Memory cost must be greater than 0", .{});
-                                            return null;
+                                            return globalObject.throwInvalidArguments2("Memory cost must be greater than 0", .{});
                                         }
 
                                         argon.memory_cost = @as(u32, @intCast(memory_cost));
@@ -1801,14 +1768,14 @@ pub const Crypto = struct {
                             unreachable;
                         } else {
                             globalObject.throwInvalidArgumentType("hash", "options.algorithm", "string");
-                            return null;
+                            return error.JSError;
                         }
                     } else if (value.isString()) {
                         const algorithm_string = value.getZigString(globalObject);
 
                         switch (PasswordObject.Algorithm.label.getWithEql(algorithm_string, JSC.ZigString.eqlComptime) orelse {
                             globalObject.throwInvalidArgumentType("hash", "algorithm", unknown_password_algorithm_message);
-                            return null;
+                            return error.JSError;
                         }) {
                             .bcrypt => {
                                 return PasswordObject.Algorithm.Value{
@@ -1833,7 +1800,7 @@ pub const Crypto = struct {
                         }
                     } else {
                         globalObject.throwInvalidArgumentType("hash", "algorithm", "string");
-                        return null;
+                        return error.JSError;
                     }
 
                     unreachable;
@@ -2221,76 +2188,63 @@ pub const Crypto = struct {
         }
 
         // Once we have bindings generator, this should be replaced with a generated function
-        pub fn JSPasswordObject__hash(
-            globalObject: *JSC.JSGlobalObject,
-            callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        pub fn JSPasswordObject__hash(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments_ = callframe.arguments(2);
             const arguments = arguments_.ptr[0..arguments_.len];
 
             if (arguments.len < 1) {
-                globalObject.throwNotEnoughArguments("hash", 1, 0);
-                return JSC.JSValue.undefined;
+                return globalObject.throwNotEnoughArguments("hash", 1, 0);
             }
 
             var algorithm = PasswordObject.Algorithm.Value.default;
 
             if (arguments.len > 1 and !arguments[1].isEmptyOrUndefinedOrNull()) {
-                algorithm = PasswordObject.Algorithm.Value.fromJS(globalObject, arguments[1]) orelse
-                    return JSC.JSValue.undefined;
+                algorithm = try PasswordObject.Algorithm.Value.fromJS(globalObject, arguments[1]);
             }
 
             const password_to_hash = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(globalObject, arguments[0], bun.default_allocator) catch {
                 if (!globalObject.hasException()) {
                     globalObject.throwInvalidArgumentType("hash", "password", "string or TypedArray");
                 }
-                return JSC.JSValue.undefined;
+                return error.JSError;
             };
+            errdefer bun.default_allocator.free(password_to_hash);
 
             if (password_to_hash.len == 0) {
                 globalObject.throwInvalidArguments("password must not be empty", .{});
-                bun.default_allocator.free(password_to_hash);
-                return JSC.JSValue.undefined;
+                return error.JSError;
             }
 
             return hash(globalObject, password_to_hash, algorithm, false);
         }
 
         // Once we have bindings generator, this should be replaced with a generated function
-        pub fn JSPasswordObject__hashSync(
-            globalObject: *JSC.JSGlobalObject,
-            callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        pub fn JSPasswordObject__hashSync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments_ = callframe.arguments(2);
             const arguments = arguments_.ptr[0..arguments_.len];
 
             if (arguments.len < 1) {
-                globalObject.throwNotEnoughArguments("hash", 1, 0);
-                return JSC.JSValue.undefined;
+                return globalObject.throwNotEnoughArguments("hash", 1, 0);
             }
 
             var algorithm = PasswordObject.Algorithm.Value.default;
 
             if (arguments.len > 1 and !arguments[1].isEmptyOrUndefinedOrNull()) {
-                algorithm = PasswordObject.Algorithm.Value.fromJS(globalObject, arguments[1]) orelse
-                    return JSC.JSValue.undefined;
+                algorithm = try PasswordObject.Algorithm.Value.fromJS(globalObject, arguments[1]);
             }
 
             var string_or_buffer = JSC.Node.StringOrBuffer.fromJS(globalObject, bun.default_allocator, arguments[0]) orelse {
                 if (!globalObject.hasException()) {
                     globalObject.throwInvalidArgumentType("hash", "password", "string or TypedArray");
                 }
-                return JSC.JSValue.undefined;
+                return error.JSError;
             };
+            defer string_or_buffer.deinit();
 
             if (string_or_buffer.slice().len == 0) {
-                globalObject.throwInvalidArguments("password must not be empty", .{});
-                string_or_buffer.deinit();
-                return JSC.JSValue.undefined;
+                return globalObject.throwInvalidArguments2("password must not be empty", .{});
             }
 
-            defer string_or_buffer.deinit();
-
             return hash(globalObject, string_or_buffer.slice(), algorithm, true);
         }
 
@@ -2382,16 +2336,12 @@ pub const Crypto = struct {
         };
 
         // Once we have bindings generator, this should be replaced with a generated function
-        pub fn JSPasswordObject__verify(
-            globalObject: *JSC.JSGlobalObject,
-            callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        pub fn JSPasswordObject__verify(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments_ = callframe.arguments(3);
             const arguments = arguments_.ptr[0..arguments_.len];
 
             if (arguments.len < 2) {
-                globalObject.throwNotEnoughArguments("verify", 2, 0);
-                return JSC.JSValue.undefined;
+                return globalObject.throwNotEnoughArguments("verify", 2, 0);
             }
 
             var algorithm: ?PasswordObject.Algorithm = null;
@@ -2399,7 +2349,7 @@ pub const Crypto = struct {
             if (arguments.len > 2 and !arguments[2].isEmptyOrUndefinedOrNull()) {
                 if (!arguments[2].isString()) {
                     globalObject.throwInvalidArgumentType("verify", "algorithm", "string");
-                    return JSC.JSValue.undefined;
+                    return error.JSError;
                 }
 
                 const algorithm_string = arguments[2].getZigString(globalObject);
@@ -2408,19 +2358,19 @@ pub const Crypto = struct {
                     if (!globalObject.hasException()) {
                         globalObject.throwInvalidArgumentType("verify", "algorithm", unknown_password_algorithm_message);
                     }
-                    return JSC.JSValue.undefined;
+                    return error.JSError;
                 };
             }
 
-            const owned_password = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(globalObject, arguments[0], bun.default_allocator) catch |err| {
-                if (err != error.JSError and !globalObject.hasException()) globalObject.throwInvalidArgumentType("verify", "password", "string or TypedArray");
-                return JSC.JSValue.undefined;
+            const owned_password = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(globalObject, arguments[0], bun.default_allocator) catch {
+                if (!globalObject.hasException()) globalObject.throwInvalidArgumentType("verify", "password", "string or TypedArray");
+                return error.JSError;
             };
 
-            const owned_hash = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(globalObject, arguments[1], bun.default_allocator) catch |err| {
+            const owned_hash = JSC.Node.StringOrBuffer.fromJSToOwnedSlice(globalObject, arguments[1], bun.default_allocator) catch {
                 bun.default_allocator.free(owned_password);
-                if (err != error.JSError and !globalObject.hasException()) globalObject.throwInvalidArgumentType("verify", "hash", "string or TypedArray");
-                return JSC.JSValue.undefined;
+                if (!globalObject.hasException()) globalObject.throwInvalidArgumentType("verify", "hash", "string or TypedArray");
+                return error.JSError;
             };
 
             if (owned_hash.len == 0) {
@@ -2437,16 +2387,12 @@ pub const Crypto = struct {
         }
 
         // Once we have bindings generator, this should be replaced with a generated function
-        pub fn JSPasswordObject__verifySync(
-            globalObject: *JSC.JSGlobalObject,
-            callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        pub fn JSPasswordObject__verifySync(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments_ = callframe.arguments(3);
             const arguments = arguments_.ptr[0..arguments_.len];
 
             if (arguments.len < 2) {
-                globalObject.throwNotEnoughArguments("verify", 2, 0);
-                return JSC.JSValue.undefined;
+                return globalObject.throwNotEnoughArguments("verify", 2, 0);
             }
 
             var algorithm: ?PasswordObject.Algorithm = null;
@@ -2512,33 +2458,25 @@ pub const Crypto = struct {
         pub const digest = JSC.wrapInstanceMethod(CryptoHasher, "digest_", false);
         pub const hash = JSC.wrapStaticMethod(CryptoHasher, "hash_", false);
 
-        fn throwHmacConsumed(globalThis: *JSC.JSGlobalObject) void {
-            globalThis.throw("HMAC has been consumed and is no longer usable", .{});
+        fn throwHmacConsumed(globalThis: *JSC.JSGlobalObject) bun.JSError {
+            return globalThis.throw2("HMAC has been consumed and is no longer usable", .{});
         }
 
-        pub fn getByteLength(
-            this: *CryptoHasher,
-            globalThis: *JSC.JSGlobalObject,
-        ) JSC.JSValue {
+        pub fn getByteLength(this: *CryptoHasher, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
             return JSC.JSValue.jsNumber(switch (this.*) {
                 .evp => |*inner| inner.size(),
                 .hmac => |inner| if (inner) |hmac| hmac.size() else {
-                    throwHmacConsumed(globalThis);
-                    return JSC.JSValue.zero;
+                    throwHmacConsumed(globalThis) catch return .zero;
                 },
                 .zig => |*inner| inner.digest_length,
             });
         }
 
-        pub fn getAlgorithm(
-            this: *CryptoHasher,
-            globalObject: *JSC.JSGlobalObject,
-        ) JSC.JSValue {
+        pub fn getAlgorithm(this: *CryptoHasher, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
             return switch (this.*) {
                 inline .evp, .zig => |*inner| ZigString.fromUTF8(bun.asByteSlice(@tagName(inner.algorithm))).toJS(globalObject),
                 .hmac => |inner| if (inner) |hmac| ZigString.fromUTF8(bun.asByteSlice(@tagName(hmac.algorithm))).toJS(globalObject) else {
-                    throwHmacConsumed(globalObject);
-                    return JSC.JSValue.zero;
+                    throwHmacConsumed(globalObject) catch return .zero;
                 },
             };
         }
@@ -2650,24 +2588,21 @@ pub const Crypto = struct {
         }
 
         // Bun.CryptoHasher(algorithm, hmacKey?: string | Buffer)
-        pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*CryptoHasher {
+        pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*CryptoHasher {
             const arguments = callframe.arguments(2);
             if (arguments.len == 0) {
-                globalThis.throwInvalidArguments("Expected an algorithm name as an argument", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Expected an algorithm name as an argument", .{});
             }
 
             const algorithm_name = arguments.ptr[0];
             if (algorithm_name.isEmptyOrUndefinedOrNull() or !algorithm_name.isString()) {
-                globalThis.throwInvalidArguments("algorithm must be a string", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("algorithm must be a string", .{});
             }
 
             const algorithm = algorithm_name.getZigString(globalThis);
 
             if (algorithm.len == 0) {
-                globalThis.throwInvalidArguments("Invalid algorithm name", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Invalid algorithm name", .{});
             }
 
             const hmac_value = arguments.ptr[1];
@@ -2680,18 +2615,16 @@ pub const Crypto = struct {
 
             if (!hmac_value.isEmptyOrUndefinedOrNull()) {
                 hmac_key = JSC.Node.StringOrBuffer.fromJS(globalThis, bun.default_allocator, hmac_value) orelse {
-                    globalThis.throwInvalidArguments("key must be a string or buffer", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("key must be a string or buffer", .{});
                 };
             }
 
             return CryptoHasher.new(brk: {
                 if (hmac_key) |*key| {
-                    const chosen_algorithm = algorithm_name.toEnumFromMap(globalThis, "algorithm", EVP.Algorithm, EVP.Algorithm.map) catch return null;
+                    const chosen_algorithm = try algorithm_name.toEnumFromMap(globalThis, "algorithm", EVP.Algorithm, EVP.Algorithm.map);
                     if (chosen_algorithm == .ripemd160) {
                         // crashes at runtime.
-                        globalThis.throw("ripemd160 is not supported", .{});
-                        return null;
+                        return globalThis.throw2("ripemd160 is not supported", .{});
                     }
 
                     break :brk .{
@@ -2701,20 +2634,20 @@ pub const Crypto = struct {
                                 if (err != 0) {
                                     const instance = createCryptoError(globalThis, err);
                                     BoringSSL.ERR_clear_error();
-                                    globalThis.throwValue(instance);
+                                    return globalThis.throwValue2(instance);
                                 } else {
                                     globalThis.throwTODO("HMAC is not supported for this algorithm yet");
+                                    return error.JSError;
                                 }
                             }
-                            return null;
+                            return error.JSError;
                         },
                     };
                 }
 
                 break :brk .{
                     .evp = EVP.byName(algorithm, globalThis) orelse return CryptoHasherZig.constructor(algorithm) orelse {
-                        globalThis.throwInvalidArguments("Unsupported algorithm {any}", .{algorithm});
-                        return null;
+                        return globalThis.throwInvalidArguments2("Unsupported algorithm {any}", .{algorithm});
                     },
                 };
             });
@@ -2727,23 +2660,21 @@ pub const Crypto = struct {
             return CryptoHasher.getConstructor(globalObject);
         }
 
-        pub fn update(this: *CryptoHasher, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn update(this: *CryptoHasher, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const thisValue = callframe.this();
             const arguments = callframe.arguments(2);
             const input = arguments.ptr[0];
             if (input.isEmptyOrUndefinedOrNull()) {
-                globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
-                return JSC.JSValue.zero;
+                return globalThis.throwInvalidArguments2("expected blob, string or buffer", .{});
             }
             const encoding = arguments.ptr[1];
-            const buffer = JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValue(globalThis, globalThis.bunVM().allocator, input, encoding) orelse {
+            const buffer = try JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValue(globalThis, globalThis.bunVM().allocator, input, encoding) orelse {
                 if (!globalThis.hasException()) globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
-                return JSC.JSValue.zero;
+                return error.JSError;
             };
             defer buffer.deinit();
             if (buffer == .blob and buffer.blob.isBunFile()) {
-                globalThis.throw("Bun.file() is not supported here yet (it needs an async version)", .{});
-                return .zero;
+                return globalThis.throw2("Bun.file() is not supported here yet (it needs an async version)", .{});
             }
 
             switch (this.*) {
@@ -2753,14 +2684,12 @@ pub const Crypto = struct {
                     if (err != 0) {
                         const instance = createCryptoError(globalThis, err);
                         BoringSSL.ERR_clear_error();
-                        globalThis.throwValue(instance);
-                        return .zero;
+                        return globalThis.throwValue2(instance);
                     }
                 },
                 .hmac => |inner| {
                     const hmac = inner orelse {
-                        throwHmacConsumed(globalThis);
-                        return JSC.JSValue.zero;
+                        return throwHmacConsumed(globalThis);
                     };
 
                     hmac.update(buffer.slice());
@@ -2768,8 +2697,7 @@ pub const Crypto = struct {
                     if (err != 0) {
                         const instance = createCryptoError(globalThis, err);
                         BoringSSL.ERR_clear_error();
-                        globalThis.throwValue(instance);
-                        return .zero;
+                        return globalThis.throwValue2(instance);
                     }
                 },
                 .zig => |*inner| {
@@ -2785,7 +2713,7 @@ pub const Crypto = struct {
             this: *CryptoHasher,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             var new: CryptoHasher = undefined;
             switch (this.*) {
                 .evp => |*inner| {
@@ -2793,15 +2721,13 @@ pub const Crypto = struct {
                 },
                 .hmac => |inner| {
                     const hmac = inner orelse {
-                        throwHmacConsumed(globalObject);
-                        return JSC.JSValue.zero;
+                        return throwHmacConsumed(globalObject);
                     };
                     new = .{
                         .hmac = hmac.copy() catch {
                             const err = createCryptoError(globalObject, BoringSSL.ERR_get_error());
                             BoringSSL.ERR_clear_error();
-                            globalObject.throwValue(err);
-                            return JSC.JSValue.zero;
+                            return globalObject.throwValue2(err);
                         },
                     };
                 },
@@ -2854,7 +2780,7 @@ pub const Crypto = struct {
                 output_digest_buf = std.mem.zeroes(EVP.Digest);
             }
 
-            const result = this.final(globalThis, output_digest_slice);
+            const result = this.final(globalThis, output_digest_slice) catch return .zero;
             if (globalThis.hasException()) {
                 return JSC.JSValue.zero;
             }
@@ -2870,19 +2796,18 @@ pub const Crypto = struct {
         fn digestToEncoding(this: *CryptoHasher, globalThis: *JSGlobalObject, encoding: JSC.Node.Encoding) JSC.JSValue {
             var output_digest_buf: EVP.Digest = std.mem.zeroes(EVP.Digest);
             const output_digest_slice: []u8 = &output_digest_buf;
-            const out = this.final(globalThis, output_digest_slice);
+            const out = this.final(globalThis, output_digest_slice) catch return .zero;
             if (globalThis.hasException()) {
                 return JSC.JSValue.zero;
             }
             return encoding.encodeWithMaxSize(globalThis, BoringSSL.EVP_MAX_MD_SIZE, out);
         }
 
-        fn final(this: *CryptoHasher, globalThis: *JSGlobalObject, output_digest_slice: []u8) []u8 {
+        fn final(this: *CryptoHasher, globalThis: *JSGlobalObject, output_digest_slice: []u8) bun.JSError![]u8 {
             return switch (this.*) {
                 .hmac => |inner| brk: {
                     const hmac: *HMAC = inner orelse {
-                        throwHmacConsumed(globalThis);
-                        return &.{};
+                        return throwHmacConsumed(globalThis);
                     };
                     this.hmac = null;
                     defer hmac.deinit();
@@ -3185,9 +3110,8 @@ pub const Crypto = struct {
                 }
             }
 
-            pub fn constructor(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*@This() {
-                const this = bun.default_allocator.create(@This()) catch return null;
-
+            pub fn constructor(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*@This() {
+                const this = try bun.default_allocator.create(@This());
                 this.* = .{ .hashing = Hasher.init() };
                 return this;
             }
@@ -3199,7 +3123,7 @@ pub const Crypto = struct {
                 return ThisHasher.getConstructor(globalObject);
             }
 
-            pub fn update(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+            pub fn update(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 if (this.digested) {
                     globalThis.ERR_INVALID_STATE(name ++ " hasher already digested, create a new instance to update", .{}).throw();
                     return .zero;
@@ -3312,36 +3236,26 @@ pub const Crypto = struct {
     pub const SHA512_256 = StaticCryptoHasher(Hashers.SHA512_256, "SHA512_256");
 };
 
-pub fn nanoseconds(
-    globalThis: *JSC.JSGlobalObject,
-    _: *JSC.CallFrame,
-) JSC.JSValue {
+pub fn nanoseconds(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const ns = globalThis.bunVM().origin_timer.read();
     return JSC.JSValue.jsNumberFromUint64(ns);
 }
 
-pub fn serve(
-    globalObject: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) JSC.JSValue {
+pub fn serve(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(2).slice();
     var config: JSC.API.ServerConfig = brk: {
-        var exception_ = [1]JSC.JSValueRef{null};
-        const exception = &exception_;
-
         var args = JSC.Node.ArgumentsSlice.init(globalObject.bunVM(), arguments);
         var config: JSC.API.ServerConfig = .{};
-        JSC.API.ServerConfig.fromJS(globalObject, &config, &args, exception);
-        if (exception[0] != null) {
-            config.deinit();
 
-            globalObject.throwValue(exception_[0].?.value());
-            return .zero;
-        }
+        try JSC.API.ServerConfig.fromJS(
+            globalObject,
+            &config,
+            &args,
+            callframe.isFromBunMain(globalObject.vm()),
+        );
 
         if (globalObject.hasException()) {
             config.deinit();
-
             return .zero;
         }
 
@@ -3397,7 +3311,7 @@ pub fn serve(
                         },
                     };
 
-                    var server = ServerType.init(config, globalObject);
+                    var server = try ServerType.init(config, globalObject);
                     if (globalObject.hasException()) {
                         return .zero;
                     }
@@ -3420,8 +3334,6 @@ pub fn serve(
             }
         },
     }
-
-    unreachable;
 }
 
 pub export fn Bun__escapeHTML16(globalObject: *JSC.JSGlobalObject, input_value: JSValue, ptr: [*]const u16, len: usize) JSValue {
@@ -3519,7 +3431,7 @@ comptime {
 pub fn allocUnsafe(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1);
     const size = arguments.ptr[0];
     if (!size.isUInt32AsAnyInt()) {
@@ -3533,7 +3445,7 @@ pub fn allocUnsafe(
 pub fn mmapFile(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     if (comptime Environment.isWindows) {
         globalThis.throwTODO("mmapFile is not supported on Windows");
         return JSC.JSValue.zero;
@@ -3641,7 +3553,7 @@ const HashObject = struct {
     pub const murmur64v2 = hashWrap(std.hash.murmur.Murmur2_64);
 
     pub fn create(globalThis: *JSC.JSGlobalObject) JSC.JSValue {
-        const function = JSC.createCallback(globalThis, ZigString.static("hash"), 1, &wyhash);
+        const function = JSC.createCallback(globalThis, ZigString.static("hash"), 1, wyhash);
         const fns = comptime .{
             "wyhash",
             "adler32",
@@ -3665,13 +3577,10 @@ const HashObject = struct {
         return function;
     }
 
-    fn hashWrap(comptime Hasher_: anytype) JSC.JSHostFunctionType {
+    fn hashWrap(comptime Hasher_: anytype) JSC.JSHostZigFunction {
         return struct {
             const Hasher = Hasher_;
-            pub fn hash(
-                globalThis: *JSC.JSGlobalObject,
-                callframe: *JSC.CallFrame,
-            ) callconv(JSC.conv) JSC.JSValue {
+            pub fn hash(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 const arguments = callframe.arguments(2).slice();
                 var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments);
                 defer args.deinit();
@@ -3832,7 +3741,7 @@ const UnsafeObject = struct {
     pub fn gcAggressionLevel(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const ret = JSValue.jsNumber(@as(i32, @intFromEnum(globalThis.bunVM().aggressive_garbage_collection)));
         const value = callframe.arguments(1).ptr[0];
 
@@ -3850,7 +3759,7 @@ const UnsafeObject = struct {
     pub fn arrayBufferToString(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const args = callframe.arguments(2).slice();
         if (args.len < 1 or !args[0].isCell() or !args[0].jsType().isTypedArray()) {
             globalThis.throwInvalidArguments("Expected an ArrayBuffer", .{});
@@ -3895,7 +3804,7 @@ const TOMLObject = struct {
     pub fn parse(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var arena = bun.ArenaAllocator.init(globalThis.allocator());
         const allocator = arena.allocator();
         defer arena.deinit();
@@ -4320,7 +4229,7 @@ pub const FFIObject = struct {
         value: JSValue,
         byteOffset: ?JSValue,
     ) JSValue {
-        if (value.isEmpty()) {
+        if (value == .zero) {
             return JSC.JSValue.jsNull();
         }
 
@@ -4576,7 +4485,7 @@ pub const FFIObject = struct {
     }
 };
 
-fn stringWidth(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+fn stringWidth(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(2).slice();
     const value = if (arguments.len > 0) arguments[0] else .undefined;
     const options_object = if (arguments.len > 1) arguments[1] else .undefined;
@@ -4592,11 +4501,11 @@ fn stringWidth(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC
     var ambiguous_as_wide = false;
 
     if (options_object.isObject()) {
-        if (options_object.getTruthy(globalObject, "countAnsiEscapeCodes")) |count_ansi_escapes_value| {
+        if (try options_object.getTruthy(globalObject, "countAnsiEscapeCodes")) |count_ansi_escapes_value| {
             if (count_ansi_escapes_value.isBoolean())
                 count_ansi_escapes = count_ansi_escapes_value.toBoolean();
         }
-        if (options_object.getTruthy(globalObject, "ambiguousIsNarrow")) |ambiguous_is_narrow| {
+        if (try options_object.getTruthy(globalObject, "ambiguousIsNarrow")) |ambiguous_is_narrow| {
             if (ambiguous_is_narrow.isBoolean())
                 ambiguous_as_wide = !ambiguous_is_narrow.toBoolean();
         }
@@ -4712,7 +4621,7 @@ pub const JSZlib = struct {
     pub fn gzipSync(
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
         defer buffer.deinit();
         return gzipOrDeflateSync(globalThis, buffer, options_val, true);
@@ -4721,7 +4630,7 @@ pub const JSZlib = struct {
     pub fn inflateSync(
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
         defer buffer.deinit();
         return gunzipOrInflateSync(globalThis, buffer, options_val, false);
@@ -4730,7 +4639,7 @@ pub const JSZlib = struct {
     pub fn deflateSync(
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
         defer buffer.deinit();
         return gzipOrDeflateSync(globalThis, buffer, options_val, false);
@@ -4739,7 +4648,7 @@ pub const JSZlib = struct {
     pub fn gunzipSync(
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const buffer, const options_val = getOptions(globalThis, callframe) orelse return .zero;
         defer buffer.deinit();
         return gunzipOrInflateSync(globalThis, buffer, options_val, true);
@@ -4750,7 +4659,7 @@ pub const JSZlib = struct {
         buffer: JSC.Node.StringOrBuffer,
         options_val_: ?JSValue,
         is_gzip: bool,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         var opts = zlib.Options{
             .gzip = is_gzip,
             .windowBits = if (is_gzip) 31 else -15,
@@ -4777,7 +4686,7 @@ pub const JSZlib = struct {
                 library = .zlib;
             }
 
-            if (options_val.getTruthy(globalThis, "library")) |library_value| {
+            if (try options_val.getTruthy(globalThis, "library")) |library_value| {
                 if (!library_value.isString()) {
                     globalThis.throwInvalidArguments("Expected library to be a string", .{});
                     return .zero;
@@ -4893,7 +4802,7 @@ pub const JSZlib = struct {
         buffer: JSC.Node.StringOrBuffer,
         options_val_: ?JSValue,
         is_gzip: bool,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         var level: ?i32 = null;
         var library: Library = .zlib;
         var windowBits: i32 = 0;
@@ -4904,7 +4813,7 @@ pub const JSZlib = struct {
                 library = .zlib;
             }
 
-            if (options_val.getTruthy(globalThis, "library")) |library_value| {
+            if (try options_val.getTruthy(globalThis, "library")) |library_value| {
                 if (!library_value.isString()) {
                     globalThis.throwInvalidArguments("Expected library to be a string", .{});
                     return .zero;
@@ -5006,7 +4915,7 @@ pub const JSZlib = struct {
 pub usingnamespace @import("./bun/subprocess.zig");
 
 const InternalTestingAPIs = struct {
-    pub fn BunInternalFunction__syntaxHighlighter(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn BunInternalFunction__syntaxHighlighter(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const args = callframe.arguments(1);
         if (args.len < 1) {
             globalThis.throwNotEnoughArguments("code", 1, 0);
diff --git a/src/bun.js/api/JSBundler.zig b/src/bun.js/api/JSBundler.zig
index baaf02ba8fc7fc..fb2f6522a825cf 100644
--- a/src/bun.js/api/JSBundler.zig
+++ b/src/bun.js/api/JSBundler.zig
@@ -62,7 +62,6 @@ pub const JSBundler = struct {
         jsx: options.JSX.Pragma = .{},
         code_splitting: bool = false,
         minify: Minify = .{},
-        server_components: ServerComponents = ServerComponents{},
         no_macros: bool = false,
         ignore_dce_annotations: bool = false,
         emit_dce_annotations: ?bool = null,
@@ -82,9 +81,7 @@ pub const JSBundler = struct {
 
         pub const List = bun.StringArrayHashMapUnmanaged(Config);
 
-        const FromJSError = OOM || JSError;
-
-        pub fn fromJS(globalThis: *JSC.JSGlobalObject, config: JSC.JSValue, plugins: *?*Plugin, allocator: std.mem.Allocator) FromJSError!Config {
+        pub fn fromJS(globalThis: *JSC.JSGlobalObject, config: JSC.JSValue, plugins: *?*Plugin, allocator: std.mem.Allocator) JSError!Config {
             var this = Config{
                 .entry_points = bun.StringSet.init(allocator),
                 .external = bun.StringSet.init(allocator),
@@ -101,11 +98,11 @@ pub const JSBundler = struct {
             errdefer this.deinit(allocator);
             errdefer if (plugins.*) |plugin| plugin.deinit();
 
-            if (config.getTruthy(globalThis, "experimentalCss")) |enable_css| {
+            if (try config.getTruthy(globalThis, "experimentalCss")) |enable_css| {
                 this.experimental_css = if (enable_css.isBoolean())
                     enable_css.toBoolean()
                 else if (enable_css.isObject()) true: {
-                    if (enable_css.getTruthy(globalThis, "chunking")) |enable_chunking| {
+                    if (try enable_css.getTruthy(globalThis, "chunking")) |enable_chunking| {
                         this.css_chunking = if (enable_chunking.isBoolean()) enable_css.toBoolean() else false;
                     }
 
@@ -121,24 +118,20 @@ pub const JSBundler = struct {
                 var i: usize = 0;
                 while (iter.next()) |plugin| : (i += 1) {
                     if (!plugin.isObject()) {
-                        globalThis.throwInvalidArguments("Expected plugin to be an object", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("Expected plugin to be an object", .{});
                     }
 
-                    if (plugin.getOptional(globalThis, "name", ZigString.Slice) catch null) |slice| {
+                    if (try plugin.getOptional(globalThis, "name", ZigString.Slice)) |slice| {
                         defer slice.deinit();
                         if (slice.len == 0) {
-                            globalThis.throwInvalidArguments("Expected plugin to have a non-empty name", .{});
-                            return error.JSError;
+                            return globalThis.throwInvalidArguments2("Expected plugin to have a non-empty name", .{});
                         }
                     } else {
-                        globalThis.throwInvalidArguments("Expected plugin to have a name", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("Expected plugin to have a name", .{});
                     }
 
-                    const function = (plugin.getFunction(globalThis, "setup") catch null) orelse {
-                        globalThis.throwInvalidArguments("Expected plugin to have a setup() function", .{});
-                        return error.JSError;
+                    const function = try plugin.getFunction(globalThis, "setup") orelse {
+                        return globalThis.throwInvalidArguments2("Expected plugin to have a setup() function", .{});
                     };
 
                     var bun_plugins: *Plugin = plugins.* orelse brk: {
@@ -166,16 +159,14 @@ pub const JSBundler = struct {
                                     plugin_result = val;
                                 },
                                 .rejected => |err| {
-                                    globalThis.throwValue(err);
-                                    return error.JSError;
+                                    return globalThis.throwValue2(err);
                                 },
                             }
                         }
                     }
 
                     if (plugin_result.toError()) |err| {
-                        globalThis.throwValue(err);
-                        return error.JSError;
+                        return globalThis.throwValue2(err);
                     } else if (globalThis.hasException()) {
                         return error.JSError;
                     }
@@ -184,13 +175,11 @@ pub const JSBundler = struct {
                 }
             }
 
-            if (config.getTruthy(globalThis, "macros")) |macros_flag| {
-                if (!macros_flag.coerce(bool, globalThis)) {
-                    this.no_macros = true;
-                }
+            if (try config.getBooleanLoose(globalThis, "macros")) |macros_flag| {
+                this.no_macros = !macros_flag;
             }
 
-            if (try config.getOptional(globalThis, "bytecode", bool)) |bytecode| {
+            if (try config.getBooleanLoose(globalThis, "bytecode")) |bytecode| {
                 this.bytecode = bytecode;
 
                 if (bytecode) {
@@ -204,8 +193,7 @@ pub const JSBundler = struct {
                 this.target = target;
 
                 if (target != .bun and this.bytecode) {
-                    globalThis.throwInvalidArguments("target must be 'bun' when bytecode is true", .{});
-                    return error.JSError;
+                    return globalThis.throwInvalidArguments2("target must be 'bun' when bytecode is true", .{});
                 }
             }
 
@@ -226,7 +214,7 @@ pub const JSBundler = struct {
                 try this.footer.appendSliceExact(slice.slice());
             }
 
-            if (config.getTruthy(globalThis, "sourcemap")) |source_map_js| {
+            if (try config.getTruthy(globalThis, "sourcemap")) |source_map_js| {
                 if (bun.FeatureFlags.breaking_changes_1_2 and config.isBoolean()) {
                     if (source_map_js == .true) {
                         this.source_map = if (has_out_dir)
@@ -251,38 +239,32 @@ pub const JSBundler = struct {
                 this.format = format;
 
                 if (this.bytecode and format != .cjs) {
-                    globalThis.throwInvalidArguments("format must be 'cjs' when bytecode is true. Eventually we'll add esm support as well.", .{});
-                    return error.JSError;
+                    return globalThis.throwInvalidArguments2("format must be 'cjs' when bytecode is true. Eventually we'll add esm support as well.", .{});
                 }
             }
 
-            // if (try config.getOptional(globalThis, "hot", bool)) |hot| {
-            //     this.hot = hot;
-            // }
-
-            if (try config.getOptional(globalThis, "splitting", bool)) |hot| {
+            if (try config.getBooleanLoose(globalThis, "splitting")) |hot| {
                 this.code_splitting = hot;
             }
 
-            if (config.getTruthy(globalThis, "minify")) |hot| {
-                if (hot.isBoolean()) {
-                    const value = hot.coerce(bool, globalThis);
+            if (try config.getTruthy(globalThis, "minify")) |minify| {
+                if (minify.isBoolean()) {
+                    const value = minify.toBoolean();
                     this.minify.whitespace = value;
                     this.minify.syntax = value;
                     this.minify.identifiers = value;
-                } else if (hot.isObject()) {
-                    if (try hot.getOptional(globalThis, "whitespace", bool)) |whitespace| {
+                } else if (minify.isObject()) {
+                    if (try minify.getBooleanLoose(globalThis, "whitespace")) |whitespace| {
                         this.minify.whitespace = whitespace;
                     }
-                    if (try hot.getOptional(globalThis, "syntax", bool)) |syntax| {
+                    if (try minify.getBooleanLoose(globalThis, "syntax")) |syntax| {
                         this.minify.syntax = syntax;
                     }
-                    if (try hot.getOptional(globalThis, "identifiers", bool)) |syntax| {
+                    if (try minify.getBooleanLoose(globalThis, "identifiers")) |syntax| {
                         this.minify.identifiers = syntax;
                     }
                 } else {
-                    globalThis.throwInvalidArguments("Expected minify to be a boolean or an object", .{});
-                    return error.JSError;
+                    return globalThis.throwInvalidArguments2("Expected minify to be a boolean or an object", .{});
                 }
             }
 
@@ -290,34 +272,27 @@ pub const JSBundler = struct {
                 var iter = entry_points.arrayIterator(globalThis);
                 while (iter.next()) |entry_point| {
                     var slice = entry_point.toSliceOrNull(globalThis) orelse {
-                        globalThis.throwInvalidArguments("Expected entrypoints to be an array of strings", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("Expected entrypoints to be an array of strings", .{});
                     };
                     defer slice.deinit();
                     try this.entry_points.insert(slice.slice());
                 }
             } else {
-                globalThis.throwInvalidArguments("Expected entrypoints to be an array of strings", .{});
-                return error.JSError;
+                return globalThis.throwInvalidArguments2("Expected entrypoints to be an array of strings", .{});
             }
 
-            if (config.getTruthy(globalThis, "emitDCEAnnotations")) |flag| {
-                if (flag.coerce(bool, globalThis)) {
-                    this.emit_dce_annotations = true;
-                }
+            if (try config.getBooleanLoose(globalThis, "emitDCEAnnotations")) |flag| {
+                this.emit_dce_annotations = flag;
             }
 
-            if (config.getTruthy(globalThis, "ignoreDCEAnnotations")) |flag| {
-                if (flag.coerce(bool, globalThis)) {
-                    this.ignore_dce_annotations = true;
-                }
+            if (try config.getBooleanLoose(globalThis, "ignoreDCEAnnotations")) |flag| {
+                this.ignore_dce_annotations = flag;
             }
 
-            if (config.getTruthy(globalThis, "conditions")) |conditions_value| {
+            if (try config.getTruthy(globalThis, "conditions")) |conditions_value| {
                 if (conditions_value.isString()) {
                     var slice = conditions_value.toSliceOrNull(globalThis) orelse {
-                        globalThis.throwInvalidArguments("Expected conditions to be an array of strings", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("Expected conditions to be an array of strings", .{});
                     };
                     defer slice.deinit();
                     try this.conditions.insert(slice.slice());
@@ -325,15 +300,13 @@ pub const JSBundler = struct {
                     var iter = conditions_value.arrayIterator(globalThis);
                     while (iter.next()) |entry_point| {
                         var slice = entry_point.toSliceOrNull(globalThis) orelse {
-                            globalThis.throwInvalidArguments("Expected conditions to be an array of strings", .{});
-                            return error.JSError;
+                            return globalThis.throwInvalidArguments2("Expected conditions to be an array of strings", .{});
                         };
                         defer slice.deinit();
                         try this.conditions.insert(slice.slice());
                     }
                 } else {
-                    globalThis.throwInvalidArguments("Expected conditions to be an array of strings", .{});
-                    return error.JSError;
+                    return globalThis.throwInvalidArguments2("Expected conditions to be an array of strings", .{});
                 }
             }
 
@@ -372,8 +345,7 @@ pub const JSBundler = struct {
                 var iter = externals.arrayIterator(globalThis);
                 while (iter.next()) |entry_point| {
                     var slice = entry_point.toSliceOrNull(globalThis) orelse {
-                        globalThis.throwInvalidArguments("Expected external to be an array of strings", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("Expected external to be an array of strings", .{});
                     };
                     defer slice.deinit();
                     try this.external.insert(slice.slice());
@@ -384,8 +356,7 @@ pub const JSBundler = struct {
                 var iter = drops.arrayIterator(globalThis);
                 while (iter.next()) |entry| {
                     var slice = entry.toSliceOrNull(globalThis) orelse {
-                        globalThis.throwInvalidArguments("Expected drop to be an array of strings", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("Expected drop to be an array of strings", .{});
                     };
                     defer slice.deinit();
                     try this.drop.insert(slice.slice());
@@ -404,7 +375,7 @@ pub const JSBundler = struct {
                 try this.public_path.appendSliceExact(slice.slice());
             }
 
-            if (config.getTruthy(globalThis, "naming")) |naming| {
+            if (try config.getTruthy(globalThis, "naming")) |naming| {
                 if (naming.isString()) {
                     if (try config.getOptional(globalThis, "naming", ZigString.Slice)) |slice| {
                         defer slice.deinit();
@@ -442,15 +413,13 @@ pub const JSBundler = struct {
                         this.names.asset.data = this.names.owned_asset.list.items;
                     }
                 } else {
-                    globalThis.throwInvalidArguments("Expected naming to be a string or an object", .{});
-                    return error.JSError;
+                    return globalThis.throwInvalidArguments2("Expected naming to be a string or an object", .{});
                 }
             }
 
             if (try config.getOwnObject(globalThis, "define")) |define| {
                 if (!define.isObject()) {
-                    globalThis.throwInvalidArguments("define must be an object", .{});
-                    return error.JSError;
+                    return globalThis.throwInvalidArguments2("define must be an object", .{});
                 }
 
                 var define_iter = JSC.JSPropertyIterator(.{
@@ -464,8 +433,7 @@ pub const JSBundler = struct {
                     const value_type = property_value.jsType();
 
                     if (!value_type.isStringLike()) {
-                        globalThis.throwInvalidArguments("define \"{s}\" must be a JSON string", .{prop});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("define \"{s}\" must be a JSON string", .{prop});
                     }
 
                     var val = JSC.ZigString.init("");
@@ -499,8 +467,7 @@ pub const JSBundler = struct {
 
                 while (loader_iter.next()) |prop| {
                     if (!prop.hasPrefixComptime(".") or prop.length() < 2) {
-                        globalThis.throwInvalidArguments("loader property names must be file extensions, such as '.txt'", .{});
-                        return error.JSError;
+                        return globalThis.throwInvalidArguments2("loader property names must be file extensions, such as '.txt'", .{});
                     }
 
                     loader_values[loader_iter.i] = try loader_iter.value.toEnumFromMap(
@@ -537,18 +504,6 @@ pub const JSBundler = struct {
             }
         };
 
-        pub const ServerComponents = struct {
-            router: JSC.Strong = .{},
-            client: std.ArrayListUnmanaged(OwnedString) = .{},
-            server: std.ArrayListUnmanaged(OwnedString) = .{},
-
-            pub fn deinit(self: *ServerComponents, allocator: std.mem.Allocator) void {
-                self.router.deinit();
-                self.client.clearAndFree(allocator);
-                self.server.clearAndFree(allocator);
-            }
-        };
-
         pub const Minify = struct {
             whitespace: bool = false,
             identifiers: bool = false,
@@ -572,7 +527,6 @@ pub const JSBundler = struct {
             self.define.deinit();
             self.dir.deinit();
             self.serve.deinit(allocator);
-            self.server_components.deinit(allocator);
             if (self.loaders) |loaders| {
                 for (loaders.extensions) |ext| {
                     bun.default_allocator.free(ext);
@@ -632,7 +586,7 @@ pub const JSBundler = struct {
     pub fn buildFn(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(1);
         return build(globalThis, arguments.slice());
     }
@@ -1191,7 +1145,7 @@ pub const BuildArtifact = struct {
         this: *BuildArtifact,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return @call(bun.callmod_inline, Blob.getText, .{ &this.blob, globalThis, callframe });
     }
 
@@ -1199,21 +1153,21 @@ pub const BuildArtifact = struct {
         this: *BuildArtifact,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return @call(bun.callmod_inline, Blob.getJSON, .{ &this.blob, globalThis, callframe });
     }
     pub fn getArrayBuffer(
         this: *BuildArtifact,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return @call(bun.callmod_inline, Blob.getArrayBuffer, .{ &this.blob, globalThis, callframe });
     }
     pub fn getSlice(
         this: *BuildArtifact,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return @call(bun.callmod_inline, Blob.getSlice, .{ &this.blob, globalThis, callframe });
     }
     pub fn getType(
@@ -1227,7 +1181,7 @@ pub const BuildArtifact = struct {
         this: *BuildArtifact,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return @call(bun.callmod_inline, Blob.getStream, .{
             &this.blob,
             globalThis,
diff --git a/src/bun.js/api/JSTranspiler.zig b/src/bun.js/api/JSTranspiler.zig
index 7015d20093e3ae..5327597fecbda1 100644
--- a/src/bun.js/api/JSTranspiler.zig
+++ b/src/bun.js/api/JSTranspiler.zig
@@ -310,7 +310,7 @@ fn exportReplacementValue(value: JSValue, globalThis: *JSGlobalObject) ?JSAst.Ex
     return null;
 }
 
-fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std.mem.Allocator, args: *JSC.Node.ArgumentsSlice, exception: JSC.C.ExceptionRef) !TranspilerOptions {
+fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std.mem.Allocator, args: *JSC.Node.ArgumentsSlice) (bun.JSError || bun.OOM)!TranspilerOptions {
     const globalThis = globalObject;
     const object = args.next() orelse return TranspilerOptions{ .log = logger.Log.init(temp_allocator) };
     if (object.isUndefinedOrNull()) return TranspilerOptions{ .log = logger.Log.init(temp_allocator) };
@@ -325,19 +325,19 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
     };
 
     if (!object.isObject()) {
-        JSC.throwInvalidArguments("Expected an object", .{}, globalObject, exception);
-        return transpiler;
+        globalObject.throwInvalidArguments("Expected an object", .{});
+        return error.JSError;
     }
 
-    if (object.getTruthy(globalObject, "define")) |define| {
+    if (try object.getTruthy(globalObject, "define")) |define| {
         define: {
             if (define.isUndefinedOrNull()) {
                 break :define;
             }
 
             if (!define.isObject()) {
-                JSC.throwInvalidArguments("define must be an object", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("define must be an object", .{});
+                return error.JSError;
             }
 
             var define_iter = JSC.JSPropertyIterator(.{
@@ -358,8 +358,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
                 const value_type = property_value.jsType();
 
                 if (!value_type.isStringLike()) {
-                    JSC.throwInvalidArguments("define \"{s}\" must be a JSON string", .{prop}, globalObject, exception);
-                    return transpiler;
+                    globalObject.throwInvalidArguments("define \"{s}\" must be a JSON string", .{prop});
+                    return error.JSError;
                 }
 
                 names[define_iter.i] = prop.toOwnedSlice(allocator) catch unreachable;
@@ -399,8 +399,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
                 var i: usize = 0;
                 while (iter.next()) |entry| {
                     if (!entry.jsType().isStringLike()) {
-                        JSC.throwInvalidArguments("external must be a string or string[]", .{}, globalObject, exception);
-                        return transpiler;
+                        globalObject.throwInvalidArguments("external must be a string or string[]", .{});
+                        return error.JSError;
                     }
 
                     var zig_str = JSC.ZigString.init("");
@@ -412,35 +412,27 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
 
                 transpiler.transform.external = externals[0..i];
             } else {
-                JSC.throwInvalidArguments("external must be a string or string[]", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("external must be a string or string[]", .{});
+                return error.JSError;
             }
         }
     }
 
     if (object.get(globalThis, "loader")) |loader| {
-        if (Loader.fromJS(globalThis, loader, exception)) |resolved| {
+        if (try Loader.fromJS(globalThis, loader)) |resolved| {
             if (!resolved.isJavaScriptLike()) {
-                JSC.throwInvalidArguments("only JavaScript-like loaders supported for now", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("only JavaScript-like loaders supported for now", .{});
+                return error.JSError;
             }
 
             transpiler.default_loader = resolved;
         }
-
-        if (exception.* != null) {
-            return transpiler;
-        }
     }
 
     if (object.get(globalThis, "target")) |target| {
-        if (Target.fromJS(globalThis, target, exception)) |resolved| {
+        if (try Target.fromJS(globalThis, target)) |resolved| {
             transpiler.transform.target = resolved.toAPI();
         }
-
-        if (exception.* != null) {
-            return transpiler;
-        }
     }
 
     if (object.get(globalThis, "tsconfig")) |tsconfig| {
@@ -451,8 +443,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
             defer out.deref();
 
             if (kind.isArray()) {
-                JSC.throwInvalidArguments("tsconfig must be a string or object", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("tsconfig must be a string or object", .{});
+                return error.JSError;
             }
 
             if (!kind.isStringLike()) {
@@ -482,7 +474,7 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         else => false,
     };
 
-    if (object.getTruthy(globalThis, "macro")) |macros| {
+    if (try object.getTruthy(globalThis, "macro")) |macros| {
         macros: {
             if (macros.isUndefinedOrNull()) break :macros;
             if (macros.isBoolean()) {
@@ -492,8 +484,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
             const kind = macros.jsType();
             const is_object = kind.isObject();
             if (!(kind.isStringLike() or is_object)) {
-                JSC.throwInvalidArguments("macro must be an object", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("macro must be an object", .{});
+                return error.JSError;
             }
 
             var out = bun.String.empty;
@@ -517,44 +509,44 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         }
     }
 
-    if (object.getOptional(globalThis, "autoImportJSX", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "autoImportJSX")) |flag| {
         transpiler.runtime.auto_import_jsx = flag;
     }
 
-    if (object.getOptional(globalThis, "allowBunRuntime", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "allowBunRuntime")) |flag| {
         transpiler.runtime.allow_runtime = flag;
     }
 
-    if (object.getOptional(globalThis, "inline", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "inline")) |flag| {
         transpiler.runtime.inlining = flag;
     }
 
-    if (object.getOptional(globalThis, "minifyWhitespace", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "minifyWhitespace")) |flag| {
         transpiler.minify_whitespace = flag;
     }
 
-    if (object.getOptional(globalThis, "deadCodeElimination", bool) catch return transpiler) |flag| {
+    if (try object.getBooleanLoose(globalThis, "deadCodeElimination")) |flag| {
         transpiler.dead_code_elimination = flag;
     }
 
-    if (object.getTruthy(globalThis, "minify")) |hot| {
-        if (hot.isBoolean()) {
-            transpiler.minify_whitespace = hot.coerce(bool, globalThis);
+    if (try object.getTruthy(globalThis, "minify")) |minify| {
+        if (minify.isBoolean()) {
+            transpiler.minify_whitespace = minify.coerce(bool, globalThis);
             transpiler.minify_syntax = transpiler.minify_whitespace;
             transpiler.minify_identifiers = transpiler.minify_syntax;
-        } else if (hot.isObject()) {
-            if (try hot.getOptional(globalThis, "whitespace", bool)) |whitespace| {
+        } else if (minify.isObject()) {
+            if (try minify.getBooleanLoose(globalThis, "whitespace")) |whitespace| {
                 transpiler.minify_whitespace = whitespace;
             }
-            if (try hot.getOptional(globalThis, "syntax", bool)) |syntax| {
+            if (try minify.getBooleanLoose(globalThis, "syntax")) |syntax| {
                 transpiler.minify_syntax = syntax;
             }
-            if (try hot.getOptional(globalThis, "identifiers", bool)) |syntax| {
+            if (try minify.getBooleanLoose(globalThis, "identifiers")) |syntax| {
                 transpiler.minify_identifiers = syntax;
             }
         } else {
-            JSC.throwInvalidArguments("Expected minify to be a boolean or an object", .{}, globalObject, exception);
-            return transpiler;
+            globalObject.throwInvalidArguments("Expected minify to be a boolean or an object", .{});
+            return error.JSError;
         }
     }
 
@@ -569,8 +561,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
             if (options.SourceMapOption.Map.fromJS(globalObject, flag)) |source| {
                 transpiler.transform.source_map = source.toAPI();
             } else {
-                JSC.throwInvalidArguments("sourcemap must be one of \"inline\", \"linked\", \"external\", or \"none\"", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("sourcemap must be one of \"inline\", \"linked\", \"external\", or \"none\"", .{});
+                return error.JSError;
             }
         }
     }
@@ -580,28 +572,28 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
     }
 
     var tree_shaking: ?bool = null;
-    if (object.getOptional(globalThis, "treeShaking", bool) catch return transpiler) |treeShaking| {
+    if (try object.getBooleanLoose(globalThis, "treeShaking")) |treeShaking| {
         tree_shaking = treeShaking;
     }
 
     var trim_unused_imports: ?bool = null;
-    if (object.getOptional(globalThis, "trimUnusedImports", bool) catch return transpiler) |trimUnusedImports| {
+    if (try object.getBooleanLoose(globalThis, "trimUnusedImports")) |trimUnusedImports| {
         trim_unused_imports = trimUnusedImports;
     }
 
-    if (object.getTruthy(globalThis, "exports")) |exports| {
+    if (try object.getTruthy(globalThis, "exports")) |exports| {
         if (!exports.isObject()) {
-            JSC.throwInvalidArguments("exports must be an object", .{}, globalObject, exception);
-            return transpiler;
+            globalObject.throwInvalidArguments("exports must be an object", .{});
+            return error.JSError;
         }
 
         var replacements = Runtime.Features.ReplaceableExport.Map{};
         errdefer replacements.clearAndFree(bun.default_allocator);
 
-        if (exports.getTruthy(globalThis, "eliminate")) |eliminate| {
+        if (try exports.getTruthy(globalThis, "eliminate")) |eliminate| {
             if (!eliminate.jsType().isArray()) {
-                JSC.throwInvalidArguments("exports.eliminate must be an array", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("exports.eliminate must be an array", .{});
+                return error.JSError;
             }
 
             var total_name_buf_len: u32 = 0;
@@ -628,8 +620,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
                         const str = value.getZigString(globalThis);
                         if (str.len == 0) continue;
                         const name = std.fmt.bufPrint(buf.items.ptr[buf.items.len..buf.capacity], "{}", .{str}) catch {
-                            JSC.throwInvalidArguments("Error reading exports.eliminate. TODO: utf-16", .{}, globalObject, exception);
-                            return transpiler;
+                            globalObject.throwInvalidArguments("Error reading exports.eliminate. TODO: utf-16", .{});
+                            return error.JSError;
                         };
                         buf.items.len += name.len;
                         if (name.len > 0) {
@@ -640,10 +632,10 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
             }
         }
 
-        if (exports.getTruthy(globalThis, "replace")) |replace| {
+        if (try exports.getTruthy(globalThis, "replace")) |replace| {
             if (!replace.isObject()) {
-                JSC.throwInvalidArguments("replace must be an object", .{}, globalObject, exception);
-                return transpiler;
+                globalObject.throwInvalidArguments("replace must be an object", .{});
+                return error.JSError;
             }
 
             var iter = JSC.JSPropertyIterator(.{
@@ -657,7 +649,7 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
 
                 // We cannot set the exception before `try` because it could be
                 // a double free with the `errdefer`.
-                defer if (exception.* != null) {
+                defer if (globalThis.hasException()) {
                     iter.deinit();
                     for (replacements.keys()) |key| {
                         bun.default_allocator.free(@constCast(key));
@@ -667,14 +659,14 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
 
                 while (iter.next()) |key_| {
                     const value = iter.value;
-                    if (value.isEmpty()) continue;
+                    if (value == .zero) continue;
 
                     const key = try key_.toOwnedSlice(bun.default_allocator);
 
                     if (!JSLexer.isIdentifier(key)) {
-                        JSC.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{key}, globalObject, exception);
+                        globalObject.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{key});
                         bun.default_allocator.free(key);
-                        return transpiler;
+                        return error.JSError;
                     }
 
                     const entry = replacements.getOrPutAssumeCapacity(key);
@@ -692,9 +684,9 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
                             const replacement_name = slice.slice();
 
                             if (!JSLexer.isIdentifier(replacement_name)) {
-                                JSC.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{replacement_name}, globalObject, exception);
+                                globalObject.throwInvalidArguments("\"{s}\" is not a valid ECMAScript identifier", .{replacement_name});
                                 slice.deinit();
-                                return transpiler;
+                                return error.JSError;
                             }
 
                             entry.value_ptr.* = .{
@@ -707,8 +699,8 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
                         }
                     }
 
-                    JSC.throwInvalidArguments("exports.replace values can only be string, null, undefined, number or boolean", .{}, globalObject, exception);
-                    return transpiler;
+                    globalObject.throwInvalidArguments("exports.replace values can only be string, null, undefined, number or boolean", .{});
+                    return error.JSError;
                 }
             }
         }
@@ -717,12 +709,12 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
         transpiler.runtime.replace_exports = replacements;
     }
 
-    if (object.getTruthy(globalThis, "logLevel")) |logLevel| {
+    if (try object.getTruthy(globalThis, "logLevel")) |logLevel| {
         if (logger.Log.Level.Map.fromJS(globalObject, logLevel)) |level| {
             transpiler.log.level = level;
         } else {
-            JSC.throwInvalidArguments("logLevel must be one of \"verbose\", \"debug\", \"info\", \"warn\", or \"error\"", .{}, globalObject, exception);
-            return transpiler;
+            globalObject.throwInvalidArguments("logLevel must be one of \"verbose\", \"debug\", \"info\", \"warn\", or \"error\"", .{});
+            return error.JSError;
         }
     }
 
@@ -732,10 +724,7 @@ fn transformOptionsFromJSC(globalObject: JSC.C.JSContextRef, temp_allocator: std
     return transpiler;
 }
 
-pub fn constructor(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) ?*Transpiler {
+pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Transpiler {
     var temp = bun.ArenaAllocator.init(getAllocator(globalThis));
     const arguments = callframe.arguments(3);
     var args = JSC.Node.ArgumentsSlice.init(
@@ -744,32 +733,22 @@ pub fn constructor(
     );
 
     defer temp.deinit();
-    var exception_ref = [_]JSC.C.JSValueRef{null};
-    const exception = &exception_ref[0];
     const transpiler_options: TranspilerOptions = if (arguments.len > 0)
-        transformOptionsFromJSC(globalThis, temp.allocator(), &args, exception) catch {
-            JSC.throwInvalidArguments("Failed to create transpiler", .{}, globalThis, exception);
-            return null;
-        }
+        try transformOptionsFromJSC(globalThis, temp.allocator(), &args)
     else
         TranspilerOptions{ .log = logger.Log.init(getAllocator(globalThis)) };
 
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return null;
+    if (globalThis.hasException()) {
+        return error.JSError;
     }
 
     const allocator = getAllocator(globalThis);
 
     if ((transpiler_options.log.warnings + transpiler_options.log.errors) > 0) {
-        globalThis.throwValue(
-            transpiler_options.log.toJS(globalThis.ptr(), allocator, "Failed to create transpiler"),
-        );
-
-        return null;
+        return globalThis.throwValue2(transpiler_options.log.toJS(globalThis, allocator, "Failed to create transpiler"));
     }
 
-    var log = allocator.create(logger.Log) catch unreachable;
+    var log = try allocator.create(logger.Log);
     log.* = transpiler_options.log;
     var bundler = Bundler.Bundler.init(
         allocator,
@@ -778,30 +757,22 @@ pub fn constructor(
         JavaScript.VirtualMachine.get().bundler.env,
     ) catch |err| {
         if ((log.warnings + log.errors) > 0) {
-            globalThis.throwValue(
-                log.toJS(globalThis.ptr(), allocator, "Failed to create transpiler"),
-            );
-
-            return null;
+            return globalThis.throwValue2(log.toJS(globalThis, allocator, "Failed to create transpiler"));
         }
 
         globalThis.throwError(err, "Error creating transpiler");
-        return null;
+        return error.JSError;
     };
     bundler.options.no_macros = transpiler_options.no_macros;
     bundler.configureLinkerWithAutoJSX(false);
     bundler.options.env.behavior = .disable;
     bundler.configureDefines() catch |err| {
         if ((log.warnings + log.errors) > 0) {
-            globalThis.throwValue(
-                log.toJS(globalThis.ptr(), allocator, "Failed to load define"),
-            );
-
-            return null;
+            return globalThis.throwValue2(log.toJS(globalThis, allocator, "Failed to load define"));
         }
 
         globalThis.throwError(err, "Failed to load define");
-        return null;
+        return error.JSError;
     };
 
     if (transpiler_options.macro_map.count() > 0) {
@@ -828,7 +799,7 @@ pub fn constructor(
     bundler.options.hot_module_reloading = transpiler_options.runtime.hot_module_reloading;
     bundler.options.react_fast_refresh = false;
 
-    const transpiler = allocator.create(Transpiler) catch unreachable;
+    const transpiler = try allocator.create(Transpiler);
     transpiler.* = Transpiler{
         .transpiler_options = transpiler_options,
         .bundler = bundler,
@@ -886,7 +857,7 @@ pub fn scan(
     this: *Transpiler,
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
     const arguments = callframe.arguments(3);
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
@@ -903,20 +874,17 @@ pub fn scan(
     defer code_holder.deinit();
     const code = code_holder.slice();
     args.eat();
-    var exception_ref = [_]JSC.C.JSValueRef{null};
-    const exception: JSC.C.ExceptionRef = &exception_ref;
 
     const loader: ?Loader = brk: {
         if (args.next()) |arg| {
             args.eat();
-            break :brk Loader.fromJS(globalThis, arg, exception);
+            break :brk try Loader.fromJS(globalThis, arg);
         }
 
         break :brk null;
     };
 
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
+    if (globalThis.hasException()) {
         return .zero;
     }
 
@@ -957,12 +925,7 @@ pub fn scan(
     const named_imports_value = namedImportsToJS(
         globalThis,
         parse_result.ast.import_records.slice(),
-        exception,
     );
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return .zero;
-    }
 
     const named_exports_value = namedExportsToJS(
         globalThis,
@@ -971,52 +934,36 @@ pub fn scan(
     return JSC.JSValue.createObject2(globalThis, imports_label, exports_label, named_imports_value, named_exports_value);
 }
 
-// pub fn build(
-//     this: *Transpiler,
-//     ctx: js.JSContextRef,
-//     _: js.JSObjectRef,
-//     _: js.JSObjectRef,
-//     arguments: []const js.JSValueRef,
-//     exception: js.ExceptionRef,
-// ) JSC.C.JSObjectRef {}
-
 pub fn transform(
     this: *Transpiler,
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
-    var exception_ref = [_]JSC.C.JSValueRef{null};
-    const exception: JSC.C.ExceptionRef = &exception_ref;
     const arguments = callframe.arguments(3);
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
     defer args.arena.deinit();
     const code_arg = args.next() orelse {
         globalThis.throwInvalidArgumentType("transform", "code", "string or Uint8Array");
-        return .zero;
+        return error.JSError;
     };
 
-    var code = JSC.Node.StringOrBuffer.fromJSWithEncodingMaybeAsync(globalThis, bun.default_allocator, code_arg, .utf8, true) orelse {
+    var code = try JSC.Node.StringOrBuffer.fromJSWithEncodingMaybeAsync(globalThis, bun.default_allocator, code_arg, .utf8, true) orelse {
         globalThis.throwInvalidArgumentType("transform", "code", "string or Uint8Array");
-        return .zero;
+        return error.JSError;
     };
+    errdefer code.deinit();
 
     args.eat();
     const loader: ?Loader = brk: {
         if (args.next()) |arg| {
             args.eat();
-            break :brk Loader.fromJS(globalThis, arg, exception);
+            break :brk try Loader.fromJS(globalThis, arg);
         }
 
         break :brk null;
     };
 
-    if (exception.* != null) {
-        code.deinit();
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return .zero;
-    }
-
     if (code == .buffer) {
         code_arg.protect();
     }
@@ -1030,7 +977,7 @@ pub fn transform(
             code_arg.unprotect();
         }
         globalThis.throwOutOfMemory();
-        return .zero;
+        return error.JSError;
     };
     task.schedule();
     return task.promise.value();
@@ -1040,10 +987,8 @@ pub fn transformSync(
     this: *Transpiler,
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
-    var exception_value = [_]JSC.C.JSValueRef{null};
-    const exception: JSC.C.ExceptionRef = &exception_value;
     const arguments = callframe.arguments(3);
 
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
@@ -1070,7 +1015,7 @@ pub fn transformSync(
         if (args.next()) |arg| {
             args.eat();
             if (arg.isNumber() or arg.isString()) {
-                break :brk Loader.fromJS(globalThis, arg, exception);
+                break :brk try Loader.fromJS(globalThis, arg);
             }
 
             if (arg.isObject()) {
@@ -1090,21 +1035,16 @@ pub fn transformSync(
             return .zero;
         }
     }
-    if (!js_ctx_value.isEmpty()) {
+    if (js_ctx_value != .zero) {
         js_ctx_value.ensureStillAlive();
     }
 
     defer {
-        if (!js_ctx_value.isEmpty()) {
+        if (js_ctx_value != .zero) {
             js_ctx_value.ensureStillAlive();
         }
     }
 
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return .zero;
-    }
-
     JSAst.Stmt.Data.Store.reset();
     JSAst.Expr.Data.Store.reset();
     defer {
@@ -1201,7 +1141,6 @@ const ImportRecord = @import("../../import_record.zig").ImportRecord;
 fn namedImportsToJS(
     global: *JSGlobalObject,
     import_records: []const ImportRecord,
-    _: JSC.C.ExceptionRef,
 ) JSC.JSValue {
     const path_label = JSC.ZigString.static("path");
     const kind_label = JSC.ZigString.static("kind");
@@ -1225,10 +1164,8 @@ pub fn scanImports(
     this: *Transpiler,
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(2);
-    var exception_val = [_]JSC.C.JSValueRef{null};
-    const exception: JSC.C.ExceptionRef = &exception_val;
     var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
     defer args.deinit();
 
@@ -1238,12 +1175,9 @@ pub fn scanImports(
     };
 
     const code_holder = JSC.Node.StringOrBuffer.fromJS(globalThis, args.arena.allocator(), code_arg) orelse {
-        if (exception.* == null) {
+        if (!globalThis.hasException()) {
             globalThis.throwInvalidArgumentType("scanImports", "code", "string or Uint8Array");
-        } else {
-            globalThis.throwValue(JSC.JSValue.c(exception.*));
         }
-
         return .zero;
     };
     args.eat();
@@ -1252,7 +1186,7 @@ pub fn scanImports(
 
     var loader: Loader = this.transpiler_options.default_loader;
     if (args.next()) |arg| {
-        if (Loader.fromJS(globalThis, arg, exception)) |_loader| {
+        if (try Loader.fromJS(globalThis, arg)) |_loader| {
             loader = _loader;
         }
         args.eat();
@@ -1263,11 +1197,6 @@ pub fn scanImports(
         return .zero;
     }
 
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return .zero;
-    }
-
     var arena = Mimalloc.Arena.init() catch unreachable;
     const prev_allocator = this.bundler.allocator;
     this.bundler.setAllocator(arena.allocator());
@@ -1329,11 +1258,6 @@ pub fn scanImports(
     const named_imports_value = namedImportsToJS(
         globalThis,
         this.scan_pass_result.import_records.items,
-        exception,
     );
-    if (exception.* != null) {
-        globalThis.throwValue(JSC.JSValue.c(exception.*));
-        return .zero;
-    }
     return named_imports_value;
 }
diff --git a/src/bun.js/api/Timer.zig b/src/bun.js/api/Timer.zig
index 3849d729ebeb69..6f9dcb62e34f35 100644
--- a/src/bun.js/api/Timer.zig
+++ b/src/bun.js/api/Timer.zig
@@ -550,7 +550,7 @@ pub const TimerObject = struct {
         return .{ timer, timer_js };
     }
 
-    pub fn doRef(this: *TimerObject, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn doRef(this: *TimerObject, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const this_value = callframe.this();
         this_value.ensureStillAlive();
 
@@ -564,7 +564,7 @@ pub const TimerObject = struct {
         return this_value;
     }
 
-    pub fn doRefresh(this: *TimerObject, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn doRefresh(this: *TimerObject, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const this_value = callframe.this();
 
         // setImmediate does not support refreshing and we do not support refreshing after cleanup
@@ -578,7 +578,7 @@ pub const TimerObject = struct {
         return this_value;
     }
 
-    pub fn doUnref(this: *TimerObject, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn doUnref(this: *TimerObject, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const this_value = callframe.this();
         this_value.ensureStillAlive();
 
@@ -643,10 +643,10 @@ pub const TimerObject = struct {
         }
     }
 
-    pub fn hasRef(this: *TimerObject, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn hasRef(this: *TimerObject, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         return JSValue.jsBoolean(this.is_keeping_event_loop_alive);
     }
-    pub fn toPrimitive(this: *TimerObject, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn toPrimitive(this: *TimerObject, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         if (!this.has_accessed_primitive) {
             this.has_accessed_primitive = true;
             const vm = VirtualMachine.get();
diff --git a/src/bun.js/api/bun/dns_resolver.zig b/src/bun.js/api/bun/dns_resolver.zig
index 16b4f8cb8499d1..0ca4a72e01a17b 100644
--- a/src/bun.js/api/bun/dns_resolver.zig
+++ b/src/bun.js/api/bun/dns_resolver.zig
@@ -1562,7 +1562,7 @@ pub const InternalDNS = struct {
     var dns_cache_errors: usize = 0;
     var getaddrinfo_calls: usize = 0;
 
-    pub fn getDNSCacheStats(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn getDNSCacheStats(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const object = JSC.JSValue.createEmptyObject(globalObject, 6);
         object.put(globalObject, JSC.ZigString.static("cacheHitsCompleted"), JSC.JSValue.jsNumber(@atomicLoad(usize, &dns_cache_hits_completed, .monotonic)));
         object.put(globalObject, JSC.ZigString.static("cacheHitsInflight"), JSC.JSValue.jsNumber(@atomicLoad(usize, &dns_cache_hits_inflight, .monotonic)));
@@ -1633,12 +1633,11 @@ pub const InternalDNS = struct {
         return req;
     }
 
-    pub fn prefetchFromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn prefetchFromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2).slice();
 
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("prefetch", 1, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("prefetch", 1, arguments.len);
         }
 
         const hostname_or_url = arguments[0];
@@ -2252,11 +2251,10 @@ pub const DNSResolver = struct {
         });
     };
 
-    pub fn resolve(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolve(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(3);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolve", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolve", 2, arguments.len);
         }
 
         const record_type: RecordType = if (arguments.len == 1)
@@ -2337,11 +2335,10 @@ pub const DNSResolver = struct {
         }
     }
 
-    pub fn reverse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn reverse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("reverse", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("reverse", 2, arguments.len);
         }
 
         const ip_value = arguments.ptr[0];
@@ -2402,11 +2399,10 @@ pub const DNSResolver = struct {
         return promise;
     }
 
-    pub fn lookup(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn lookup(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("lookup", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("lookup", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2472,11 +2468,10 @@ pub const DNSResolver = struct {
         };
     }
 
-    pub fn resolveSrv(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveSrv(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveSrv", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveSrv", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2503,11 +2498,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_ares_srv_reply, "srv", name.slice(), globalThis);
     }
 
-    pub fn resolveSoa(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveSoa(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveSoa", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveSoa", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2529,11 +2523,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_ares_soa_reply, "soa", name.slice(), globalThis);
     }
 
-    pub fn resolveCaa(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveCaa(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveCaa", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveCaa", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2560,11 +2553,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_ares_caa_reply, "caa", name.slice(), globalThis);
     }
 
-    pub fn resolveNs(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveNs(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveNs", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveNs", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2586,11 +2578,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_hostent, "ns", name.slice(), globalThis);
     }
 
-    pub fn resolvePtr(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolvePtr(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolvePtr", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolvePtr", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2617,11 +2608,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_hostent, "ptr", name.slice(), globalThis);
     }
 
-    pub fn resolveCname(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveCname(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveCname", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveCname", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2648,11 +2638,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_hostent, "cname", name.slice(), globalThis);
     }
 
-    pub fn resolveMx(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveMx(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveMx", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveMx", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2679,11 +2668,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_ares_mx_reply, "mx", name.slice(), globalThis);
     }
 
-    pub fn resolveNaptr(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveNaptr(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveNaptr", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveNaptr", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2710,11 +2698,10 @@ pub const DNSResolver = struct {
         return resolver.doResolveCAres(c_ares.struct_ares_naptr_reply, "naptr", name.slice(), globalThis);
     }
 
-    pub fn resolveTxt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn resolveTxt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2);
         if (arguments.len < 1) {
-            globalThis.throwNotEnoughArguments("resolveTxt", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("resolveTxt", 2, arguments.len);
         }
 
         const name_value = arguments.ptr[0];
@@ -2831,7 +2818,7 @@ pub const DNSResolver = struct {
         return promise;
     }
 
-    pub fn getServers(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn getServers(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         _ = callframe;
 
         var vm = globalThis.bunVM();
@@ -2917,11 +2904,10 @@ pub const DNSResolver = struct {
     // Resolves the given address and port into a host name and service using the operating system's underlying getnameinfo implementation.
     // If address is not a valid IP address, a TypeError will be thrown. The port will be coerced to a number.
     // If it is not a legal port, a TypeError will be thrown.
-    pub fn lookupService(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn lookupService(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(3);
         if (arguments.len < 2) {
-            globalThis.throwNotEnoughArguments("lookupService", 3, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("lookupService", 3, arguments.len);
         }
 
         const addr_value = arguments.ptr[0];
@@ -3004,98 +2990,37 @@ pub const DNSResolver = struct {
     }
 
     comptime {
-        @export(
-            resolve,
-            .{
-                .name = "Bun__DNSResolver__resolve",
-            },
-        );
-        @export(
-            lookup,
-            .{
-                .name = "Bun__DNSResolver__lookup",
-            },
-        );
-        @export(
-            resolveTxt,
-            .{
-                .name = "Bun__DNSResolver__resolveTxt",
-            },
-        );
-        @export(
-            resolveSoa,
-            .{
-                .name = "Bun__DNSResolver__resolveSoa",
-            },
-        );
-        @export(
-            resolveMx,
-            .{
-                .name = "Bun__DNSResolver__resolveMx",
-            },
-        );
-        @export(
-            resolveNaptr,
-            .{
-                .name = "Bun__DNSResolver__resolveNaptr",
-            },
-        );
-        @export(
-            resolveSrv,
-            .{
-                .name = "Bun__DNSResolver__resolveSrv",
-            },
-        );
-        @export(
-            resolveCaa,
-            .{
-                .name = "Bun__DNSResolver__resolveCaa",
-            },
-        );
-        @export(
-            resolveNs,
-            .{
-                .name = "Bun__DNSResolver__resolveNs",
-            },
-        );
-        @export(
-            resolvePtr,
-            .{
-                .name = "Bun__DNSResolver__resolvePtr",
-            },
-        );
-        @export(
-            resolveCname,
-            .{
-                .name = "Bun__DNSResolver__resolveCname",
-            },
-        );
-        @export(
-            getServers,
-            .{
-                .name = "Bun__DNSResolver__getServers",
-            },
-        );
-        @export(
-            reverse,
-            .{
-                .name = "Bun__DNSResolver__reverse",
-            },
-        );
-        @export(
-            lookupService,
-            .{
-                .name = "Bun__DNSResolver__lookupService",
-            },
-        );
-        @export(
-            InternalDNS.prefetchFromJS,
-            .{
-                .name = "Bun__DNSResolver__prefetch",
-            },
-        );
-        @export(InternalDNS.getDNSCacheStats, .{
-            .name = "Bun__DNSResolver__getCacheStats",
-        });
+        const js_resolve = JSC.toJSHostFunction(resolve);
+        @export(js_resolve, .{ .name = "Bun__DNSResolver__resolve" });
+        const js_lookup = JSC.toJSHostFunction(lookup);
+        @export(js_lookup, .{ .name = "Bun__DNSResolver__lookup" });
+        const js_resolveTxt = JSC.toJSHostFunction(resolveTxt);
+        @export(js_resolveTxt, .{ .name = "Bun__DNSResolver__resolveTxt" });
+        const js_resolveSoa = JSC.toJSHostFunction(resolveSoa);
+        @export(js_resolveSoa, .{ .name = "Bun__DNSResolver__resolveSoa" });
+        const js_resolveMx = JSC.toJSHostFunction(resolveMx);
+        @export(js_resolveMx, .{ .name = "Bun__DNSResolver__resolveMx" });
+        const js_resolveNaptr = JSC.toJSHostFunction(resolveNaptr);
+        @export(js_resolveNaptr, .{ .name = "Bun__DNSResolver__resolveNaptr" });
+        const js_resolveSrv = JSC.toJSHostFunction(resolveSrv);
+        @export(js_resolveSrv, .{ .name = "Bun__DNSResolver__resolveSrv" });
+        const js_resolveCaa = JSC.toJSHostFunction(resolveCaa);
+        @export(js_resolveCaa, .{ .name = "Bun__DNSResolver__resolveCaa" });
+        const js_resolveNs = JSC.toJSHostFunction(resolveNs);
+        @export(js_resolveNs, .{ .name = "Bun__DNSResolver__resolveNs" });
+        const js_resolvePtr = JSC.toJSHostFunction(resolvePtr);
+        @export(js_resolvePtr, .{ .name = "Bun__DNSResolver__resolvePtr" });
+        const js_resolveCname = JSC.toJSHostFunction(resolveCname);
+        @export(js_resolveCname, .{ .name = "Bun__DNSResolver__resolveCname" });
+        const js_getServers = JSC.toJSHostFunction(getServers);
+        @export(js_getServers, .{ .name = "Bun__DNSResolver__getServers" });
+        const js_reverse = JSC.toJSHostFunction(reverse);
+        @export(js_reverse, .{ .name = "Bun__DNSResolver__reverse" });
+        const js_lookupService = JSC.toJSHostFunction(lookupService);
+        @export(js_lookupService, .{ .name = "Bun__DNSResolver__lookupService" });
+        const js_prefetchFromJS = JSC.toJSHostFunction(InternalDNS.prefetchFromJS);
+        @export(js_prefetchFromJS, .{ .name = "Bun__DNSResolver__prefetch" });
+        const js_getDNSCacheStats = JSC.toJSHostFunction(InternalDNS.getDNSCacheStats);
+        @export(js_getDNSCacheStats, .{ .name = "Bun__DNSResolver__getCacheStats" });
     }
 };
diff --git a/src/bun.js/api/bun/h2_frame_parser.zig b/src/bun.js/api/bun/h2_frame_parser.zig
index 535db8e26fa934..3b25462133544f 100644
--- a/src/bun.js/api/bun/h2_frame_parser.zig
+++ b/src/bun.js/api/bun/h2_frame_parser.zig
@@ -290,7 +290,7 @@ const SingleValueHeaders = bun.ComptimeStringMap(void, .{
     .{"x-content-type-options"},
 });
 
-fn jsGetUnpackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+fn jsGetUnpackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
     var settings: FullSettingsPayload = .{};
 
@@ -325,7 +325,7 @@ fn jsGetUnpackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.Call
     }
 }
 
-fn jsAssertSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+fn jsAssertSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const args_list = callframe.arguments(1);
     if (args_list.len < 1) {
         globalObject.throw("Expected settings to be a object", .{});
@@ -427,7 +427,7 @@ fn jsAssertSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame
     return .undefined;
 }
 
-fn jsGetPackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+fn jsGetPackedSettings(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     var settings: FullSettingsPayload = .{};
     const args_list = callframe.arguments(1);
 
@@ -586,15 +586,14 @@ const Handlers = struct {
         return this.vm.eventLoop().runCallbackWithResult(callback, this.globalObject, thisValue, data);
     }
 
-    pub fn fromJS(globalObject: *JSC.JSGlobalObject, opts: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Handlers {
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, opts: JSC.JSValue) bun.JSError!Handlers {
         var handlers = Handlers{
             .vm = globalObject.bunVM(),
             .globalObject = globalObject,
         };
 
         if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-            exception.* = JSC.toInvalidArguments("Expected \"handlers\" to be an object", .{}, globalObject).asObjectRef();
-            return null;
+            return globalObject.throwInvalidArguments2("Expected \"handlers\" to be an object", .{});
         }
 
         const pairs = .{
@@ -615,10 +614,9 @@ const Handlers = struct {
         };
 
         inline for (pairs) |pair| {
-            if (opts.getTruthy(globalObject, pair.@"1")) |callback_value| {
+            if (try opts.getTruthy(globalObject, pair.@"1")) |callback_value| {
                 if (!callback_value.isCell() or !callback_value.isCallable(globalObject.vm())) {
-                    exception.* = JSC.toInvalidArguments(comptime std.fmt.comptimePrint("Expected \"{s}\" callback to be a function", .{pair.@"1"}), .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"{s}\" callback to be a function", .{pair[1]});
                 }
 
                 @field(handlers, pair.@"0") = callback_value;
@@ -627,8 +625,7 @@ const Handlers = struct {
 
         if (opts.fastGet(globalObject, .@"error")) |callback_value| {
             if (!callback_value.isCell() or !callback_value.isCallable(globalObject.vm())) {
-                exception.* = JSC.toInvalidArguments("Expected \"error\" callback to be a function", .{}, globalObject).asObjectRef();
-                return null;
+                return globalObject.throwInvalidArguments2("Expected \"error\" callback to be a function", .{});
             }
 
             handlers.onError = callback_value;
@@ -636,19 +633,16 @@ const Handlers = struct {
 
         // onWrite is required for duplex support or if more than 1 parser is attached to the same socket (unliked)
         if (handlers.onWrite == .zero) {
-            exception.* = JSC.toInvalidArguments("Expected at least \"write\" callback", .{}, globalObject).asObjectRef();
-            return null;
+            return globalObject.throwInvalidArguments2("Expected at least \"write\" callback", .{});
         }
 
-        if (opts.getTruthy(globalObject, "binaryType")) |binary_type_value| {
+        if (try opts.getTruthy(globalObject, "binaryType")) |binary_type_value| {
             if (!binary_type_value.isString()) {
-                exception.* = JSC.toInvalidArguments("Expected \"binaryType\" to be a string", .{}, globalObject).asObjectRef();
-                return null;
+                return globalObject.throwInvalidArguments2("Expected \"binaryType\" to be a string", .{});
             }
 
-            handlers.binary_type = BinaryType.fromJSValue(globalObject, binary_type_value) orelse {
-                exception.* = JSC.toInvalidArguments("Expected 'binaryType' to be 'arraybuffer', 'uint8array', 'buffer'", .{}, globalObject).asObjectRef();
-                return null;
+            handlers.binary_type = try BinaryType.fromJSValue(globalObject, binary_type_value) orelse {
+                return globalObject.throwInvalidArguments2("Expected 'binaryType' to be 'ArrayBuffer', 'Uint8Array', or 'Buffer'", .{});
             };
         }
 
@@ -2338,7 +2332,7 @@ pub const H2FrameParser = struct {
         return DirectWriterStruct{ .writer = this };
     }
 
-    pub fn setEncoding(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn setEncoding(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2354,23 +2348,20 @@ pub const H2FrameParser = struct {
         return .undefined;
     }
 
-    pub fn loadSettingsFromJSValue(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, options: JSC.JSValue) bool {
+    pub fn loadSettingsFromJSValue(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, options: JSC.JSValue) bun.JSError!void {
         if (options.isEmptyOrUndefinedOrNull() or !options.isObject()) {
-            globalObject.throw("Expected settings to be a object", .{});
-            return false;
+            return globalObject.throw2("Expected settings to be a object", .{});
         }
 
         if (options.get(globalObject, "headerTableSize")) |headerTableSize| {
             if (headerTableSize.isNumber()) {
                 const headerTableSizeValue = headerTableSize.toInt32();
                 if (headerTableSizeValue > MAX_HEADER_TABLE_SIZE or headerTableSizeValue < 0) {
-                    globalObject.throw("Expected headerTableSize to be a number between 0 and 2^32-1", .{});
-                    return false;
+                    return globalObject.throw2("Expected headerTableSize to be a number between 0 and 2^32-1", .{});
                 }
                 this.localSettings.headerTableSize = @intCast(headerTableSizeValue);
             } else if (!headerTableSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected headerTableSize to be a number", .{});
-                return false;
+                return globalObject.throw2("Expected headerTableSize to be a number", .{});
             }
         }
 
@@ -2378,8 +2369,7 @@ pub const H2FrameParser = struct {
             if (enablePush.isBoolean()) {
                 this.localSettings.enablePush = if (enablePush.asBoolean()) 1 else 0;
             } else if (!enablePush.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected enablePush to be a boolean", .{});
-                return false;
+                return globalObject.throw2("Expected enablePush to be a boolean", .{});
             }
         }
 
@@ -2387,13 +2377,11 @@ pub const H2FrameParser = struct {
             if (initialWindowSize.isNumber()) {
                 const initialWindowSizeValue = initialWindowSize.toInt32();
                 if (initialWindowSizeValue > MAX_HEADER_TABLE_SIZE or initialWindowSizeValue < 0) {
-                    globalObject.throw("Expected initialWindowSize to be a number between 0 and 2^32-1", .{});
-                    return false;
+                    return globalObject.throw2("Expected initialWindowSize to be a number between 0 and 2^32-1", .{});
                 }
                 this.localSettings.initialWindowSize = @intCast(initialWindowSizeValue);
             } else if (!initialWindowSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected initialWindowSize to be a number", .{});
-                return false;
+                return globalObject.throw2("Expected initialWindowSize to be a number", .{});
             }
         }
 
@@ -2401,13 +2389,11 @@ pub const H2FrameParser = struct {
             if (maxFrameSize.isNumber()) {
                 const maxFrameSizeValue = maxFrameSize.toInt32();
                 if (maxFrameSizeValue > MAX_FRAME_SIZE or maxFrameSizeValue < 16384) {
-                    globalObject.throw("Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{});
-                    return false;
+                    return globalObject.throw2("Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{});
                 }
                 this.localSettings.maxFrameSize = @intCast(maxFrameSizeValue);
             } else if (!maxFrameSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxFrameSize to be a number", .{});
-                return false;
+                return globalObject.throw2("Expected maxFrameSize to be a number", .{});
             }
         }
 
@@ -2415,13 +2401,11 @@ pub const H2FrameParser = struct {
             if (maxConcurrentStreams.isNumber()) {
                 const maxConcurrentStreamsValue = maxConcurrentStreams.toInt32();
                 if (maxConcurrentStreamsValue > MAX_HEADER_TABLE_SIZE or maxConcurrentStreamsValue < 0) {
-                    globalObject.throw("Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{});
-                    return false;
+                    return globalObject.throw2("Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{});
                 }
                 this.localSettings.maxConcurrentStreams = @intCast(maxConcurrentStreamsValue);
             } else if (!maxConcurrentStreams.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxConcurrentStreams to be a number", .{});
-                return false;
+                return globalObject.throw2("Expected maxConcurrentStreams to be a number", .{});
             }
         }
 
@@ -2429,13 +2413,11 @@ pub const H2FrameParser = struct {
             if (maxHeaderListSize.isNumber()) {
                 const maxHeaderListSizeValue = maxHeaderListSize.toInt32();
                 if (maxHeaderListSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderListSizeValue < 0) {
-                    globalObject.throw("Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{});
-                    return false;
+                    return globalObject.throw2("Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{});
                 }
                 this.localSettings.maxHeaderListSize = @intCast(maxHeaderListSizeValue);
             } else if (!maxHeaderListSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxHeaderListSize to be a number", .{});
-                return false;
+                return globalObject.throw2("Expected maxHeaderListSize to be a number", .{});
             }
         }
 
@@ -2443,19 +2425,17 @@ pub const H2FrameParser = struct {
             if (maxHeaderSize.isNumber()) {
                 const maxHeaderSizeValue = maxHeaderSize.toInt32();
                 if (maxHeaderSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderSizeValue < 0) {
-                    globalObject.throw("Expected maxHeaderSize to be a number between 0 and 2^32-1", .{});
-                    return false;
+                    return globalObject.throw2("Expected maxHeaderSize to be a number between 0 and 2^32-1", .{});
                 }
                 this.localSettings.maxHeaderListSize = @intCast(maxHeaderSizeValue);
             } else if (!maxHeaderSize.isEmptyOrUndefinedOrNull()) {
-                globalObject.throw("Expected maxHeaderSize to be a number", .{});
-                return false;
+                return globalObject.throw2("Expected maxHeaderSize to be a number", .{});
             }
         }
-        return true;
+        return;
     }
 
-    pub fn updateSettings(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn updateSettings(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2465,15 +2445,12 @@ pub const H2FrameParser = struct {
 
         const options = args_list.ptr[0];
 
-        if (this.loadSettingsFromJSValue(globalObject, options)) {
-            this.setSettings(this.localSettings);
-            return .undefined;
-        }
-
-        return .zero;
+        try this.loadSettingsFromJSValue(globalObject, options);
+        this.setSettings(this.localSettings);
+        return .undefined;
     }
 
-    pub fn getCurrentState(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn getCurrentState(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         var result = JSValue.createEmptyObject(globalObject, 9);
         result.put(globalObject, JSC.ZigString.static("effectiveLocalWindowSize"), JSC.JSValue.jsNumber(this.windowSize));
@@ -2489,7 +2466,7 @@ pub const H2FrameParser = struct {
         result.put(globalObject, JSC.ZigString.static("outboundQueueSize"), JSC.JSValue.jsNumber(this.outboundQueueSize));
         return result;
     }
-    pub fn goaway(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn goaway(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(3);
         if (args_list.len < 1) {
@@ -2540,7 +2517,7 @@ pub const H2FrameParser = struct {
         return .undefined;
     }
 
-    pub fn ping(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn ping(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2564,7 +2541,7 @@ pub const H2FrameParser = struct {
         return .zero;
     }
 
-    pub fn getEndAfterHeaders(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn getEndAfterHeaders(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2592,7 +2569,7 @@ pub const H2FrameParser = struct {
         return JSC.JSValue.jsBoolean(stream.endAfterHeaders);
     }
 
-    pub fn isStreamAborted(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn isStreamAborted(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2623,7 +2600,7 @@ pub const H2FrameParser = struct {
         // closed with cancel = aborted
         return JSC.JSValue.jsBoolean(stream.state == .CLOSED and stream.rstCode == @intFromEnum(ErrorCode.CANCEL));
     }
-    pub fn getStreamState(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn getStreamState(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2660,7 +2637,7 @@ pub const H2FrameParser = struct {
         return state;
     }
 
-    pub fn setStreamPriority(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn setStreamPriority(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(2);
         if (args_list.len < 2) {
@@ -2759,7 +2736,7 @@ pub const H2FrameParser = struct {
         }
         return JSC.JSValue.jsBoolean(true);
     }
-    pub fn rstStream(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn rstStream(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(2);
         if (args_list.len < 2) {
@@ -2824,7 +2801,7 @@ pub const H2FrameParser = struct {
         return (this.writeBuffer.len + this.queuedDataSize) / 1024 / 1024;
     }
     // get memory in bytes
-    pub fn getBufferSize(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn getBufferSize(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         return JSC.JSValue.jsNumber(this.writeBuffer.len + this.queuedDataSize);
     }
@@ -2916,7 +2893,7 @@ pub const H2FrameParser = struct {
             }
         }
     }
-    pub fn noTrailers(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn noTrailers(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -2957,12 +2934,11 @@ pub const H2FrameParser = struct {
         return .undefined;
     }
 
-    pub fn sendTrailers(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn sendTrailers(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(3);
         if (args_list.len < 3) {
-            globalObject.throw("Expected stream, headers and sensitiveHeaders arguments", .{});
-            return .zero;
+            return globalObject.throw2("Expected stream, headers and sensitiveHeaders arguments", .{});
         }
 
         const stream_arg = args_list.ptr[0];
@@ -2970,29 +2946,24 @@ pub const H2FrameParser = struct {
         const sensitive_arg = args_list.ptr[2];
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Expected stream to be a number", .{});
-            return .zero;
+            return globalObject.throw2("Expected stream to be a number", .{});
         }
 
         const stream_id = stream_arg.toU32();
         if (stream_id == 0 or stream_id > MAX_STREAM_ID) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw2("Invalid stream id", .{});
         }
 
         var stream = this.streams.getPtr(@intCast(stream_id)) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw2("Invalid stream id", .{});
         };
 
         if (!headers_arg.isObject()) {
-            globalObject.throw("Expected headers to be an object", .{});
-            return .zero;
+            return globalObject.throw2("Expected headers to be an object", .{});
         }
 
         if (!sensitive_arg.isObject()) {
-            globalObject.throw("Expected sensitiveHeaders to be an object", .{});
-            return .zero;
+            return globalObject.throw2("Expected sensitiveHeaders to be an object", .{});
         }
 
         // max frame size will be always at least 16384
@@ -3015,14 +2986,12 @@ pub const H2FrameParser = struct {
 
             if (header_name.charAt(0) == ':') {
                 const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_PSEUDOHEADER, "\"{s}\" is an invalid pseudoheader or is used incorrectly", .{name}, globalObject);
-                globalObject.throwValue(exception);
-                return .zero;
+                return globalObject.throwValue2(exception);
             }
 
-            var js_value = headers_arg.getTruthy(globalObject, name) orelse {
+            var js_value = try headers_arg.getTruthy(globalObject, name) orelse {
                 const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_HEADER_VALUE, "Invalid value for header \"{s}\"", .{name}, globalObject);
-                globalObject.throwValue(exception);
-                return .zero;
+                return globalObject.throwValue2(exception);
             };
 
             if (js_value.jsType().isArray()) {
@@ -3031,24 +3000,21 @@ pub const H2FrameParser = struct {
 
                 if (SingleValueHeaders.has(name) and value_iter.len > 1) {
                     const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_SINGLE_VALUE_HEADER, "Header field \"{s}\" must only have a single value", .{name}, globalObject);
-                    globalObject.throwValue(exception);
-                    return .zero;
+                    return globalObject.throwValue2(exception);
                 }
 
                 while (value_iter.next()) |item| {
                     if (item.isEmptyOrUndefinedOrNull()) {
                         const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_HEADER_VALUE, "Invalid value for header \"{s}\"", .{name}, globalObject);
-                        globalObject.throwValue(exception);
-                        return .zero;
+                        return globalObject.throwValue2(exception);
                     }
 
                     const value_str = item.toStringOrNull(globalObject) orelse {
                         const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_HEADER_VALUE, "Invalid value for header \"{s}\"", .{name}, globalObject);
-                        globalObject.throwValue(exception);
-                        return .zero;
+                        return globalObject.throwValue2(exception);
                     };
 
-                    const never_index = sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
+                    const never_index = try sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
 
                     const value_slice = value_str.toSlice(globalObject, bun.default_allocator);
                     defer value_slice.deinit();
@@ -3067,11 +3033,10 @@ pub const H2FrameParser = struct {
             } else {
                 const value_str = js_value.toStringOrNull(globalObject) orelse {
                     const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_HEADER_VALUE, "Invalid value for header \"{s}\"", .{name}, globalObject);
-                    globalObject.throwValue(exception);
-                    return .zero;
+                    return globalObject.throwValue2(exception);
                 };
 
-                const never_index = sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
+                const never_index = try sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
 
                 const value_slice = value_str.toSlice(globalObject, bun.default_allocator);
                 defer value_slice.deinit();
@@ -3111,26 +3076,23 @@ pub const H2FrameParser = struct {
         this.dispatchWithExtra(.onStreamEnd, identifier, JSC.JSValue.jsNumber(@intFromEnum(stream.state)));
         return .undefined;
     }
-    pub fn writeStream(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn writeStream(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args = callframe.argumentsUndef(5);
         const stream_arg, const data_arg, const encoding_arg, const close_arg, const callback_arg = args.ptr;
 
         if (!stream_arg.isNumber()) {
-            globalObject.throw("Expected stream to be a number", .{});
-            return .zero;
+            return globalObject.throw2("Expected stream to be a number", .{});
         }
 
         const stream_id = stream_arg.toU32();
         if (stream_id == 0 or stream_id > MAX_STREAM_ID) {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw2("Invalid stream id", .{});
         }
         const close = close_arg.toBoolean();
 
         var stream = this.streams.getPtr(@intCast(stream_id)) orelse {
-            globalObject.throw("Invalid stream id", .{});
-            return .zero;
+            return globalObject.throw2("Invalid stream id", .{});
         };
         if (!stream.canSendData()) {
             this.dispatchWriteCallback(callback_arg);
@@ -3143,23 +3105,24 @@ pub const H2FrameParser = struct {
             }
 
             if (!encoding_arg.isString()) {
-                return globalObject.throwInvalidArgumentTypeValue("write", "encoding", encoding_arg);
+                _ = globalObject.throwInvalidArgumentTypeValue("write", "encoding", encoding_arg);
+                return error.JSError;
             }
 
             break :brk JSC.Node.Encoding.fromJS(encoding_arg, globalObject) orelse {
                 if (!globalObject.hasException()) return globalObject.throwInvalidArgumentTypeValue("write", "encoding", encoding_arg);
-                return .zero;
+                return error.JSError;
             };
         };
 
-        var buffer: JSC.Node.StringOrBuffer = JSC.Node.StringOrBuffer.fromJSWithEncoding(
+        var buffer: JSC.Node.StringOrBuffer = try JSC.Node.StringOrBuffer.fromJSWithEncoding(
             globalObject,
             bun.default_allocator,
             data_arg,
             encoding,
         ) orelse {
             if (!globalObject.hasException()) return globalObject.throwInvalidArgumentTypeValue("write", "Buffer or String", data_arg);
-            return .zero;
+            return error.JSError;
         };
         defer buffer.deinit();
 
@@ -3188,11 +3151,11 @@ pub const H2FrameParser = struct {
         return stream_id;
     }
 
-    pub fn hasNativeRead(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn hasNativeRead(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         return JSC.JSValue.jsBoolean(this.native_socket == .tcp or this.native_socket == .tls);
     }
 
-    pub fn getNextStream(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn getNextStream(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const id = this.getNextStreamID();
@@ -3203,7 +3166,7 @@ pub const H2FrameParser = struct {
         return JSC.JSValue.jsNumber(id);
     }
 
-    pub fn getStreamContext(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn getStreamContext(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -3225,7 +3188,7 @@ pub const H2FrameParser = struct {
         return stream.jsContext.get() orelse .undefined;
     }
 
-    pub fn setStreamContext(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setStreamContext(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(2);
         if (args_list.len < 2) {
@@ -3252,7 +3215,7 @@ pub const H2FrameParser = struct {
         return .undefined;
     }
 
-    pub fn getAllStreams(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn getAllStreams(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         const array = JSC.JSValue.createEmptyArray(globalObject, this.streams.count());
@@ -3265,7 +3228,7 @@ pub const H2FrameParser = struct {
         }
         return array;
     }
-    pub fn emitAbortToAllStreams(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn emitAbortToAllStreams(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         var it = StreamResumableIterator.init(this);
         while (it.next()) |stream| {
@@ -3285,7 +3248,7 @@ pub const H2FrameParser = struct {
         }
         return .undefined;
     }
-    pub fn emitErrorToAllStreams(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn emitErrorToAllStreams(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         const args_list = callframe.arguments(1);
@@ -3311,13 +3274,13 @@ pub const H2FrameParser = struct {
         return .undefined;
     }
 
-    pub fn flushFromJS(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn flushFromJS(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         return JSC.JSValue.jsNumber(this.flush());
     }
 
-    pub fn request(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn request(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const args_list = callframe.arguments(5);
@@ -3405,7 +3368,7 @@ pub const H2FrameParser = struct {
                     continue;
                 }
 
-                var js_value = headers_arg.getTruthy(globalObject, name) orelse {
+                var js_value = try headers_arg.getTruthy(globalObject, name) orelse {
                     const exception = JSC.toTypeError(.ERR_HTTP2_INVALID_HEADER_VALUE, "Invalid value for header \"{s}\"", .{name}, globalObject);
                     globalObject.throwValue(exception);
                     return .zero;
@@ -3435,7 +3398,7 @@ pub const H2FrameParser = struct {
                             return .zero;
                         };
 
-                        const never_index = sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
+                        const never_index = try sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
 
                         const value_slice = value_str.toSlice(globalObject, bun.default_allocator);
                         defer value_slice.deinit();
@@ -3462,7 +3425,7 @@ pub const H2FrameParser = struct {
                         return .zero;
                     };
 
-                    const never_index = sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
+                    const never_index = try sensitive_arg.getTruthy(globalObject, "neverIndex") != null;
 
                     const value_slice = value_str.toSlice(globalObject, bun.default_allocator);
                     defer value_slice.deinit();
@@ -3658,7 +3621,7 @@ pub const H2FrameParser = struct {
         return JSC.JSValue.jsNumber(stream_id);
     }
 
-    pub fn read(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn read(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -3700,7 +3663,7 @@ pub const H2FrameParser = struct {
         this.detachNativeSocket();
     }
 
-    pub fn setNativeSocketFromJS(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setNativeSocketFromJS(this: *H2FrameParser, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
@@ -3752,32 +3715,26 @@ pub const H2FrameParser = struct {
         }
     }
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*H2FrameParser {
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*H2FrameParser {
         const args_list = callframe.arguments(1);
         if (args_list.len < 1) {
-            globalObject.throw("Expected 1 argument", .{});
-            return null;
+            return globalObject.throw2("Expected 1 argument", .{});
         }
 
         const options = args_list.ptr[0];
         if (options.isEmptyOrUndefinedOrNull() or options.isBoolean() or !options.isObject()) {
-            globalObject.throwInvalidArguments("expected options as argument", .{});
-            return null;
+            return globalObject.throwInvalidArguments2("expected options as argument", .{});
         }
 
-        var exception: JSC.C.JSValueRef = null;
         const context_obj = options.get(globalObject, "context") orelse {
-            globalObject.throw("Expected \"context\" option", .{});
-            return null;
+            return globalObject.throw2("Expected \"context\" option", .{});
         };
         var handler_js = JSC.JSValue.zero;
         if (options.get(globalObject, "handlers")) |handlers_| {
             handler_js = handlers_;
         }
-        var handlers = Handlers.fromJS(globalObject, handler_js, &exception) orelse {
-            globalObject.throwValue(exception.?.value());
-            return null;
-        };
+        var handlers = try Handlers.fromJS(globalObject, handler_js);
+        errdefer handlers.deinit();
 
         var this = brk: {
             if (ENABLE_ALLOCATOR_POOL) {
@@ -3817,6 +3774,8 @@ pub const H2FrameParser = struct {
                 });
             }
         };
+        errdefer this.deinit();
+
         // check if socket is provided, and if it is a valid native socket
         if (options.get(globalObject, "native")) |socket_js| {
             if (JSTLSSocket.fromJS(socket_js)) |socket| {
@@ -3841,11 +3800,7 @@ pub const H2FrameParser = struct {
         }
         if (options.get(globalObject, "settings")) |settings_js| {
             if (!settings_js.isEmptyOrUndefinedOrNull()) {
-                if (!this.loadSettingsFromJSValue(globalObject, settings_js)) {
-                    this.deinit();
-                    handlers.deinit();
-                    return null;
-                }
+                try this.loadSettingsFromJSValue(globalObject, settings_js);
 
                 if (settings_js.get(globalObject, "maxOutstandingPings")) |max_pings| {
                     if (max_pings.isNumber()) {
@@ -3894,7 +3849,7 @@ pub const H2FrameParser = struct {
         }
         return this;
     }
-    pub fn detachFromJS(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn detachFromJS(this: *H2FrameParser, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         this.detach(false);
         return .undefined;
diff --git a/src/bun.js/api/bun/socket.zig b/src/bun.js/api/bun/socket.zig
index 04c4032b04e42a..530641217e976b 100644
--- a/src/bun.js/api/bun/socket.zig
+++ b/src/bun.js/api/bun/socket.zig
@@ -20,6 +20,7 @@ const X509 = @import("./x509.zig");
 const Async = bun.Async;
 const uv = bun.windows.libuv;
 const H2FrameParser = @import("./h2_frame_parser.zig").H2FrameParser;
+const NodePath = @import("../../node/path.zig");
 noinline fn getSSLException(globalThis: *JSC.JSGlobalObject, defaultMessage: []const u8) JSValue {
     var zig_str: ZigString = ZigString.init("");
     var output_buf: [4096]u8 = undefined;
@@ -217,15 +218,14 @@ const Handlers = struct {
         return true;
     }
 
-    pub fn fromJS(globalObject: *JSC.JSGlobalObject, opts: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Handlers {
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, opts: JSC.JSValue) bun.JSError!Handlers {
         var handlers = Handlers{
             .vm = globalObject.bunVM(),
             .globalObject = globalObject,
         };
 
         if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-            exception.* = JSC.toInvalidArguments("Expected \"socket\" to be an object", .{}, globalObject).asObjectRef();
-            return null;
+            return globalObject.throwInvalidArguments2("Expected \"socket\" to be an object", .{});
         }
 
         const pairs = .{
@@ -240,10 +240,9 @@ const Handlers = struct {
             .{ "onHandshake", "handshake" },
         };
         inline for (pairs) |pair| {
-            if (opts.getTruthyComptime(globalObject, pair.@"1")) |callback_value| {
+            if (try opts.getTruthyComptime(globalObject, pair.@"1")) |callback_value| {
                 if (!callback_value.isCell() or !callback_value.isCallable(globalObject.vm())) {
-                    exception.* = JSC.toInvalidArguments(comptime std.fmt.comptimePrint("Expected \"{s}\" callback to be a function", .{pair.@"1"}), .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"{s}\" callback to be a function", .{pair[1]});
                 }
 
                 @field(handlers, pair.@"0") = callback_value;
@@ -251,19 +250,16 @@ const Handlers = struct {
         }
 
         if (handlers.onData == .zero and handlers.onWritable == .zero) {
-            exception.* = JSC.toInvalidArguments("Expected at least \"data\" or \"drain\" callback", .{}, globalObject).asObjectRef();
-            return null;
+            return globalObject.throwInvalidArguments2("Expected at least \"data\" or \"drain\" callback", .{});
         }
 
-        if (opts.getTruthy(globalObject, "binaryType")) |binary_type_value| {
+        if (try opts.getTruthy(globalObject, "binaryType")) |binary_type_value| {
             if (!binary_type_value.isString()) {
-                exception.* = JSC.toInvalidArguments("Expected \"binaryType\" to be a string", .{}, globalObject).asObjectRef();
-                return null;
+                return globalObject.throwInvalidArguments2("Expected \"binaryType\" to be a string", .{});
             }
 
-            handlers.binary_type = BinaryType.fromJSValue(globalObject, binary_type_value) orelse {
-                exception.* = JSC.toInvalidArguments("Expected 'binaryType' to be 'arraybuffer', 'uint8array', 'buffer'", .{}, globalObject).asObjectRef();
-                return null;
+            handlers.binary_type = try BinaryType.fromJSValue(globalObject, binary_type_value) orelse {
+                return globalObject.throwInvalidArguments2("Expected 'binaryType' to be 'ArrayBuffer', 'Uint8Array', or 'Buffer'", .{});
             };
         }
 
@@ -315,12 +311,7 @@ pub const SocketConfig = struct {
     exclusive: bool = false,
     allowHalfOpen: bool = false,
 
-    pub fn fromJS(
-        vm: *JSC.VirtualMachine,
-        opts: JSC.JSValue,
-        globalObject: *JSC.JSGlobalObject,
-        exception: JSC.C.ExceptionRef,
-    ) ?SocketConfig {
+    pub fn fromJS(vm: *JSC.VirtualMachine, opts: JSC.JSValue, globalObject: *JSC.JSGlobalObject) bun.JSError!SocketConfig {
         var hostname_or_unix: JSC.ZigString.Slice = JSC.ZigString.Slice.empty;
         var port: ?u16 = null;
         var exclusive = false;
@@ -329,31 +320,28 @@ pub const SocketConfig = struct {
         var ssl: ?JSC.API.ServerConfig.SSLConfig = null;
         var default_data = JSValue.zero;
 
-        if (opts.getTruthy(globalObject, "tls")) |tls| {
+        if (try opts.getTruthy(globalObject, "tls")) |tls| {
             if (tls.isBoolean()) {
                 if (tls.toBoolean()) {
                     ssl = JSC.API.ServerConfig.SSLConfig.zero;
                 }
             } else {
-                if (JSC.API.ServerConfig.SSLConfig.inJS(vm, globalObject, tls, exception)) |ssl_config| {
+                if (try JSC.API.ServerConfig.SSLConfig.fromJS(vm, globalObject, tls)) |ssl_config| {
                     ssl = ssl_config;
-                } else if (exception.* != null) {
-                    return null;
                 }
             }
         }
 
         hostname_or_unix: {
-            if (opts.getTruthy(globalObject, "fd")) |fd_| {
+            if (try opts.getTruthy(globalObject, "fd")) |fd_| {
                 if (fd_.isNumber()) {
                     break :hostname_or_unix;
                 }
             }
 
-            if (opts.getTruthy(globalObject, "unix")) |unix_socket| {
+            if (try opts.getTruthy(globalObject, "unix")) |unix_socket| {
                 if (!unix_socket.isString()) {
-                    exception.* = JSC.toInvalidArguments("Expected \"unix\" to be a string", .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"unix\" to be a string", .{});
                 }
 
                 hostname_or_unix = unix_socket.getZigString(globalObject).toSlice(bun.default_allocator);
@@ -368,17 +356,16 @@ pub const SocketConfig = struct {
                 }
             }
 
-            if (opts.getTruthy(globalObject, "exclusive")) |_| {
+            if (try opts.getTruthy(globalObject, "exclusive")) |_| {
                 exclusive = true;
             }
-            if (opts.getTruthy(globalObject, "allowHalfOpen")) |_| {
+            if (try opts.getTruthy(globalObject, "allowHalfOpen")) |_| {
                 allowHalfOpen = true;
             }
 
-            if (opts.getTruthy(globalObject, "hostname") orelse opts.getTruthy(globalObject, "host")) |hostname| {
+            if (try opts.getTruthy(globalObject, "hostname") orelse try opts.getTruthy(globalObject, "host")) |hostname| {
                 if (!hostname.isString()) {
-                    exception.* = JSC.toInvalidArguments("Expected \"hostname\" to be a string", .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"hostname\" to be a string", .{});
                 }
 
                 var port_value = opts.get(globalObject, "port") orelse JSValue.zero;
@@ -394,25 +381,22 @@ pub const SocketConfig = struct {
                 }
 
                 if (port_value.isEmptyOrUndefinedOrNull()) {
-                    exception.* = JSC.toInvalidArguments("Expected \"port\" to be a number between 0 and 65535", .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"port\" to be a number between 0 and 65535", .{});
                 }
 
                 const porti32 = port_value.coerceToInt32(globalObject);
                 if (globalObject.hasException()) {
-                    return null;
+                    return error.JSError;
                 }
 
                 if (porti32 < 0 or porti32 > 65535) {
-                    exception.* = JSC.toInvalidArguments("Expected \"port\" to be a number between 0 and 65535", .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"port\" to be a number between 0 and 65535", .{});
                 }
 
                 port = @intCast(porti32);
 
                 if (hostname_or_unix.len == 0) {
-                    exception.* = JSC.toInvalidArguments("Expected \"hostname\" to be a non-empty string", .{}, globalObject).asObjectRef();
-                    return null;
+                    return globalObject.throwInvalidArguments2("Expected \"hostname\" to be a non-empty string", .{});
                 }
 
                 if (hostname_or_unix.len > 0) {
@@ -421,18 +405,14 @@ pub const SocketConfig = struct {
             }
 
             if (hostname_or_unix.len == 0) {
-                exception.* = JSC.toInvalidArguments("Expected \"unix\" or \"hostname\" to be a non-empty string", .{}, globalObject).asObjectRef();
-                return null;
+                return globalObject.throwInvalidArguments2("Expected \"unix\" or \"hostname\" to be a non-empty string", .{});
             }
 
-            exception.* = JSC.toInvalidArguments("Expected either \"hostname\" or \"unix\"", .{}, globalObject).asObjectRef();
-            return null;
+            return globalObject.throwInvalidArguments2("Expected either \"hostname\" or \"unix\"", .{});
         }
+        errdefer hostname_or_unix.deinit();
 
-        var handlers = Handlers.fromJS(globalObject, opts.get(globalObject, "socket") orelse JSValue.zero, exception) orelse {
-            hostname_or_unix.deinit();
-            return null;
-        };
+        var handlers = try Handlers.fromJS(globalObject, opts.get(globalObject, "socket") orelse JSValue.zero);
 
         if (opts.fastGet(globalObject, .data)) |default_data_value| {
             default_data = default_data_value;
@@ -452,6 +432,38 @@ pub const SocketConfig = struct {
     }
 };
 
+fn isValidPipeName(pipe_name: []const u8) bool {
+    if (!Environment.isWindows) {
+        return false;
+    }
+    // check for valid pipe names
+    // at minimum we need to have \\.\pipe\ or \\?\pipe\ + 1 char that is not a separator
+    return pipe_name.len > 9 and
+        NodePath.isSepWindowsT(u8, pipe_name[0]) and
+        NodePath.isSepWindowsT(u8, pipe_name[1]) and
+        (pipe_name[2] == '.' or pipe_name[2] == '?') and
+        NodePath.isSepWindowsT(u8, pipe_name[3]) and
+        strings.eql(pipe_name[4..8], "pipe") and
+        NodePath.isSepWindowsT(u8, pipe_name[8]) and
+        !NodePath.isSepWindowsT(u8, pipe_name[9]);
+}
+
+fn normalizePipeName(pipe_name: []const u8, buffer: []u8) ?[]const u8 {
+    if (Environment.isWindows) {
+        bun.assert(pipe_name.len < buffer.len);
+        if (!isValidPipeName(pipe_name)) {
+            return null;
+        }
+        // normalize pipe name with can have mixed slashes
+        // pipes are simple and this will be faster than using node:path.resolve()
+        // we dont wanna to normalize the pipe name it self only the pipe identifier (//./pipe/, //?/pipe/, etc)
+        @memcpy(buffer[0..9], "\\\\.\\pipe\\");
+        @memcpy(buffer[9..pipe_name.len], pipe_name[9..]);
+        return buffer[0..pipe_name.len];
+    } else {
+        return null;
+    }
+}
 pub const Listener = struct {
     pub const log = Output.scoped(.Listener, false);
 
@@ -533,7 +545,7 @@ pub const Listener = struct {
         }
     };
 
-    pub fn reload(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn reload(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const args = callframe.arguments(1);
 
         if (args.len < 1 or (this.listener == .none and this.handlers.active_connections == 0)) {
@@ -547,17 +559,12 @@ pub const Listener = struct {
             return .zero;
         }
 
-        var exception: JSC.C.JSValueRef = null;
-
         const socket_obj = opts.get(globalObject, "socket") orelse {
             globalObject.throw("Expected \"socket\" object", .{});
             return .zero;
         };
 
-        const handlers = Handlers.fromJS(globalObject, socket_obj, &exception) orelse {
-            globalObject.throwValue(exception.?.value());
-            return .zero;
-        };
+        const handlers = try Handlers.fromJS(globalObject, socket_obj);
 
         var prev_handlers = &this.handlers;
         prev_handlers.unprotect();
@@ -567,25 +574,16 @@ pub const Listener = struct {
         return JSValue.jsUndefined();
     }
 
-    pub fn listen(globalObject: *JSC.JSGlobalObject, opts: JSValue) JSValue {
+    pub fn listen(globalObject: *JSC.JSGlobalObject, opts: JSValue) bun.JSError!JSValue {
         log("listen", .{});
-        var exception_ = [1]JSC.JSValueRef{null};
-        const exception: JSC.C.ExceptionRef = &exception_;
-        defer {
-            if (exception_[0] != null) {
-                globalObject.throwValue(exception_[0].?.value());
-            }
-        }
         if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-            exception.* = JSC.toInvalidArguments("Expected object", .{}, globalObject).asObjectRef();
+            globalObject.throwInvalidArguments("Expected object", .{});
             return .zero;
         }
 
         const vm = JSC.VirtualMachine.get();
 
-        var socket_config = SocketConfig.fromJS(vm, opts, globalObject, exception) orelse {
-            return .zero;
-        };
+        var socket_config = try SocketConfig.fromJS(vm, opts, globalObject);
 
         var hostname_or_unix = socket_config.hostname_or_unix;
         const port = socket_config.port;
@@ -606,8 +604,9 @@ pub const Listener = struct {
         if (Environment.isWindows) {
             if (port == null) {
                 // we check if the path is a named pipe otherwise we try to connect using AF_UNIX
-                const pipe_name = hostname_or_unix.slice();
-                if (strings.startsWith(pipe_name, "\\\\.\\pipe\\") or strings.startsWith(pipe_name, "\\\\?\\pipe\\")) {
+                const slice = hostname_or_unix.slice();
+                var buf: bun.PathBuffer = undefined;
+                if (normalizePipeName(slice, buf[0..])) |pipe_name| {
                     const connection: Listener.UnixOrHost = .{ .unix = (hostname_or_unix.cloneIfNeeded(bun.default_allocator) catch bun.outOfMemory()).slice() };
                     if (ssl_enabled) {
                         if (ssl.?.protos) |p| {
@@ -638,7 +637,7 @@ pub const Listener = struct {
                     this.listener = .{
                         // we need to add support for the backlog parameter on listen here we use the default value of nodejs
                         .namedPipe = WindowsNamedPipeListeningContext.listen(globalObject, pipe_name, 511, ssl, this) catch {
-                            exception.* = JSC.toInvalidArguments("Failed to listen at {s}", .{pipe_name}, globalObject).asObjectRef();
+                            globalObject.throwInvalidArguments("Failed to listen at {s}", .{pipe_name});
                             this.deinit();
                             return .zero;
                         },
@@ -681,7 +680,7 @@ pub const Listener = struct {
                 }
             }
 
-            exception.* = err.asObjectRef();
+            globalObject.throwValue(err);
             return .zero;
         };
 
@@ -757,10 +756,7 @@ pub const Listener = struct {
                     defer bun.default_allocator.free(host);
                     break :brk uws.us_socket_context_listen_unix(@intFromBool(ssl_enabled), socket_context, host, host.len, socket_flags, 8, &errno);
                 },
-                .fd => {
-                    // don't call listen() on an fd
-                    return .zero;
-                },
+                .fd => unreachable,
             }
         } orelse {
             defer {
@@ -781,8 +777,7 @@ pub const Listener = struct {
                     err.put(globalObject, ZigString.static("code"), ZigString.init(@tagName(str)).toJS(globalObject));
                 }
             }
-            exception.* = err.asObjectRef();
-
+            globalObject.throwValue(err);
             return .zero;
         };
 
@@ -832,9 +827,8 @@ pub const Listener = struct {
         onCreate(false, socket);
     }
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*Listener {
-        globalObject.throw("Cannot construct Listener", .{});
-        return null;
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*Listener {
+        return globalObject.throw2("Cannot construct Listener", .{});
     }
 
     pub fn onNamePipeCreated(comptime ssl: bool, listener: *Listener) *NewSocket(ssl) {
@@ -886,7 +880,7 @@ pub const Listener = struct {
         socket.setTimeout(120);
     }
 
-    pub fn addServerName(this: *Listener, global: *JSC.JSGlobalObject, hostname: JSValue, tls: JSValue) JSValue {
+    pub fn addServerName(this: *Listener, global: *JSC.JSGlobalObject, hostname: JSValue, tls: JSValue) bun.JSError!JSValue {
         if (!this.ssl) {
             global.throwInvalidArguments("addServerName requires SSL support", .{});
             return .zero;
@@ -906,28 +900,22 @@ pub const Listener = struct {
             global.throwInvalidArguments("hostname pattern cannot be empty", .{});
             return .zero;
         }
-        var exception_ref = [_]JSC.C.JSValueRef{null};
-        const exception: JSC.C.ExceptionRef = &exception_ref;
 
-        if (JSC.API.ServerConfig.SSLConfig.inJS(JSC.VirtualMachine.get(), global, tls, exception)) |ssl_config| {
+        if (try JSC.API.ServerConfig.SSLConfig.fromJS(JSC.VirtualMachine.get(), global, tls)) |ssl_config| {
             // to keep nodejs compatibility, we allow to replace the server name
             uws.us_socket_context_remove_server_name(1, this.socket_context, server_name);
             uws.us_bun_socket_context_add_server_name(1, this.socket_context, server_name, ssl_config.asUSockets(), null);
         }
 
-        if (exception.* != null) {
-            global.throwValue(exception_ref[0].?.value());
-            return .zero;
-        }
         return JSValue.jsUndefined();
     }
 
-    pub fn dispose(this: *Listener, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn dispose(this: *Listener, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.doStop(true);
         return .undefined;
     }
 
-    pub fn stop(this: *Listener, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn stop(this: *Listener, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(1);
         log("close", .{});
 
@@ -1034,7 +1022,7 @@ pub const Listener = struct {
         return JSValue.jsNumber(this.connection.host.port);
     }
 
-    pub fn ref(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn ref(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const this_value = callframe.this();
         if (this.listener == .none) return JSValue.jsUndefined();
         this.poll_ref.ref(globalObject.bunVM());
@@ -1042,7 +1030,7 @@ pub const Listener = struct {
         return JSValue.jsUndefined();
     }
 
-    pub fn unref(this: *Listener, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn unref(this: *Listener, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.poll_ref.unref(globalObject.bunVM());
         if (this.handlers.active_connections == 0) {
             this.strong_self.clear();
@@ -1050,26 +1038,14 @@ pub const Listener = struct {
         return JSValue.jsUndefined();
     }
 
-    pub fn connect(
-        globalObject: *JSC.JSGlobalObject,
-        opts: JSValue,
-    ) JSValue {
-        var exception_ = [1]JSC.JSValueRef{null};
-        const exception: JSC.C.ExceptionRef = &exception_;
-        defer {
-            if (exception_[0] != null) {
-                globalObject.throwValue(exception_[0].?.value());
-            }
-        }
+    pub fn connect(globalObject: *JSC.JSGlobalObject, opts: JSValue) bun.JSError!JSValue {
         if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
-            exception.* = JSC.toInvalidArguments("Expected options object", .{}, globalObject).asObjectRef();
+            globalObject.throwInvalidArguments("Expected options object", .{});
             return .zero;
         }
         const vm = globalObject.bunVM();
 
-        const socket_config = SocketConfig.fromJS(vm, opts, globalObject, exception) orelse {
-            return .zero;
-        };
+        const socket_config = try SocketConfig.fromJS(vm, opts, globalObject);
 
         var hostname_or_unix = socket_config.hostname_or_unix;
         const port = socket_config.port;
@@ -1085,7 +1061,7 @@ pub const Listener = struct {
         vm.eventLoop().ensureWaker();
 
         var connection: Listener.UnixOrHost = blk: {
-            if (opts.getTruthy(globalObject, "fd")) |fd_| {
+            if (try opts.getTruthy(globalObject, "fd")) |fd_| {
                 if (fd_.isNumber()) {
                     const fd = fd_.asFileDescriptor();
                     break :blk .{ .fd = fd };
@@ -1099,9 +1075,14 @@ pub const Listener = struct {
         };
 
         if (Environment.isWindows) {
+            var buf: bun.PathBuffer = undefined;
+            var pipe_name: ?[]const u8 = null;
             const isNamedPipe = switch (connection) {
                 // we check if the path is a named pipe otherwise we try to connect using AF_UNIX
-                .unix => |pipe_name| strings.startsWith(pipe_name, "\\\\.\\pipe\\") or strings.startsWith(pipe_name, "\\\\?\\pipe\\"),
+                .unix => |slice| brk: {
+                    pipe_name = normalizePipeName(slice, buf[0..]);
+                    break :brk (pipe_name != null);
+                },
                 .fd => |fd| brk: {
                     const uvfd = bun.uvfdcast(fd);
                     const fd_type = uv.uv_guess_handle(uvfd);
@@ -1146,7 +1127,7 @@ pub const Listener = struct {
                     tls.poll_ref.ref(handlers.vm);
                     tls.ref();
                     if (connection == .unix) {
-                        const named_pipe = WindowsNamedPipeContext.connect(globalObject, connection.unix, ssl, .{ .tls = tls }) catch {
+                        const named_pipe = WindowsNamedPipeContext.connect(globalObject, pipe_name.?, ssl, .{ .tls = tls }) catch {
                             return promise_value;
                         };
                         tls.socket = TLSSocket.Socket.fromNamedPipe(named_pipe);
@@ -1172,7 +1153,7 @@ pub const Listener = struct {
                     tcp.poll_ref.ref(handlers.vm);
 
                     if (connection == .unix) {
-                        const named_pipe = WindowsNamedPipeContext.connect(globalObject, connection.unix, null, .{ .tcp = tcp }) catch {
+                        const named_pipe = WindowsNamedPipeContext.connect(globalObject, pipe_name.?, null, .{ .tcp = tcp }) catch {
                             return promise_value;
                         };
                         tcp.socket = TCPSocket.Socket.fromNamedPipe(named_pipe);
@@ -1200,7 +1181,7 @@ pub const Listener = struct {
                 .syscall = bun.String.static("connect"),
                 .code = if (port == null) bun.String.static("ENOENT") else bun.String.static("ECONNREFUSED"),
             };
-            exception.* = err.toErrorInstance(globalObject).asObjectRef();
+            globalObject.throwValue(err.toErrorInstance(globalObject));
             handlers.unprotect();
             connection.deinit();
             return .zero;
@@ -1454,11 +1435,11 @@ fn NewSocket(comptime ssl: bool) type {
             }
         }
 
-        pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*This {
-            globalObject.throw("Cannot construct Socket", .{});
-            return null;
+        pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*This {
+            return globalObject.throw2("Cannot construct Socket", .{});
         }
-        pub fn resumeFromJS(this: *This, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+
+        pub fn resumeFromJS(this: *This, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
             JSC.markBinding(@src());
 
             log("resume", .{});
@@ -1467,7 +1448,7 @@ fn NewSocket(comptime ssl: bool) type {
             }
             return .undefined;
         }
-        pub fn pauseFromJS(this: *This, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+        pub fn pauseFromJS(this: *This, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
             JSC.markBinding(@src());
 
             log("pause", .{});
@@ -1477,7 +1458,7 @@ fn NewSocket(comptime ssl: bool) type {
             return .undefined;
         }
 
-        pub fn setKeepAlive(this: *This, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+        pub fn setKeepAlive(this: *This, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
             JSC.markBinding(@src());
             const args = callframe.arguments(2);
 
@@ -1505,7 +1486,7 @@ fn NewSocket(comptime ssl: bool) type {
             return JSValue.jsBoolean(this.socket.setKeepAlive(enabled, initialDelay));
         }
 
-        pub fn setNoDelay(this: *This, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+        pub fn setNoDelay(this: *This, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
             JSC.markBinding(@src());
 
             const args = callframe.arguments(1);
@@ -1885,21 +1866,11 @@ fn NewSocket(comptime ssl: bool) type {
                 }
             } else {
                 // call handhsake callback with authorized and authorization error if has one
-                var authorization_error: JSValue = undefined;
-                if (ssl_error.error_no == 0) {
-                    authorization_error = JSValue.jsNull();
-                } else {
-                    const code = if (ssl_error.code == null) "" else ssl_error.code[0..bun.len(ssl_error.code)];
-
-                    const reason = if (ssl_error.reason == null) "" else ssl_error.reason[0..bun.len(ssl_error.reason)];
-
-                    const fallback = JSC.SystemError{
-                        .code = bun.String.createUTF8(code),
-                        .message = bun.String.createUTF8(reason),
-                    };
+                const authorization_error: JSValue = if (ssl_error.error_no == 0)
+                    JSValue.jsNull()
+                else
+                    ssl_error.toJS(globalObject);
 
-                    authorization_error = fallback.toErrorInstance(globalObject);
-                }
                 result = callback.call(globalObject, this_value, &[_]JSValue{
                     this_value,
                     JSValue.jsBoolean(authorized),
@@ -2050,7 +2021,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             const args = callframe.arguments(1);
             if (this.socket.isDetached()) return JSValue.jsUndefined();
@@ -2074,7 +2045,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
 
             if (this.socket.isDetached()) {
@@ -2104,7 +2075,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
 
             if (this.socket.isDetached()) {
@@ -2181,7 +2152,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (this.socket.isDetached()) {
                 this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
                 return JSValue.jsBoolean(false);
@@ -2199,7 +2170,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (this.socket.isDetached()) {
                 this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
                 return JSValue.jsBoolean(false);
@@ -2231,7 +2202,9 @@ fn NewSocket(comptime ssl: bool) type {
             const buffer: JSC.Node.StringOrBuffer = if (data_value.isUndefined())
                 JSC.Node.StringOrBuffer.empty
             else
-                JSC.Node.StringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalObject, stack_fallback.get(), data_value, encoding_value, false) orelse {
+                JSC.Node.StringOrBuffer.fromJSWithEncodingValueMaybeAsync(globalObject, stack_fallback.get(), data_value, encoding_value, false) catch {
+                    return .fail;
+                } orelse {
                     if (!globalObject.hasException()) {
                         _ = globalObject.throwInvalidArgumentTypeValue("data", "string, buffer, or blob", data_value);
                     }
@@ -2340,7 +2313,9 @@ fn NewSocket(comptime ssl: bool) type {
             const buffer: JSC.Node.BlobOrStringOrBuffer = if (args[0].isUndefined())
                 JSC.Node.BlobOrStringOrBuffer{ .string_or_buffer = JSC.Node.StringOrBuffer.empty }
             else
-                JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsyncAllowRequestResponse(globalObject, stack_fallback.get(), args[0], encoding_value, false, true) orelse {
+                JSC.Node.BlobOrStringOrBuffer.fromJSWithEncodingValueMaybeAsyncAllowRequestResponse(globalObject, stack_fallback.get(), args[0], encoding_value, false, true) catch {
+                    return .fail;
+                } orelse {
                     if (!globalObject.hasException()) {
                         _ = globalObject.throwInvalidArgumentTypeValue("data", "string, buffer, or blob", args[0]);
                     }
@@ -2472,7 +2447,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             _: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             this.internalFlush();
             return JSValue.jsUndefined();
@@ -2482,7 +2457,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             _: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             this.closeAndDetach(.failure);
             return JSValue.jsUndefined();
@@ -2492,7 +2467,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             _: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             const args = callframe.arguments(1);
             this.buffered_data_for_node_net.deinitWithAllocator(bun.default_allocator);
@@ -2509,7 +2484,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
 
             var args = callframe.argumentsUndef(5);
@@ -2533,14 +2508,14 @@ fn NewSocket(comptime ssl: bool) type {
             };
         }
 
-        pub fn jsRef(this: *This, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+        pub fn jsRef(this: *This, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
             JSC.markBinding(@src());
             if (this.socket.isDetached()) return JSValue.jsUndefined();
             this.poll_ref.ref(globalObject.bunVM());
             return JSValue.jsUndefined();
         }
 
-        pub fn jsUnref(this: *This, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+        pub fn jsUnref(this: *This, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
             JSC.markBinding(@src());
             this.poll_ref.unref(globalObject.bunVM());
             return JSValue.jsUndefined();
@@ -2587,7 +2562,7 @@ fn NewSocket(comptime ssl: bool) type {
             this.deref();
         }
 
-        pub fn reload(this: *This, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+        pub fn reload(this: *This, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
             const args = callframe.arguments(1);
 
             if (args.len < 1) {
@@ -2605,17 +2580,12 @@ fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
-            var exception: JSC.C.JSValueRef = null;
-
             const socket_obj = opts.get(globalObject, "socket") orelse {
                 globalObject.throw("Expected \"socket\" option", .{});
                 return .zero;
             };
 
-            const handlers = Handlers.fromJS(globalObject, socket_obj, &exception) orelse {
-                globalObject.throwValue(exception.?.value());
-                return .zero;
-            };
+            const handlers = try Handlers.fromJS(globalObject, socket_obj);
 
             var prev_handlers = this.handlers;
             prev_handlers.unprotect();
@@ -2629,7 +2599,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             _: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2642,7 +2612,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2683,7 +2653,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2700,7 +2670,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2723,7 +2693,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2743,8 +2713,6 @@ fn NewSocket(comptime ssl: bool) type {
             var arena: bun.ArenaAllocator = bun.ArenaAllocator.init(bun.default_allocator);
             defer arena.deinit();
 
-            var exception_ref = [_]JSC.C.JSValueRef{null};
-            const exception: JSC.C.ExceptionRef = &exception_ref;
             if (JSC.Node.StringOrBuffer.fromJS(globalObject, arena.allocator(), session_arg)) |sb| {
                 defer sb.deinit();
                 const session_slice = sb.slice();
@@ -2756,9 +2724,6 @@ fn NewSocket(comptime ssl: bool) type {
                     return .zero;
                 }
                 return JSValue.jsUndefined();
-            } else if (exception.* != null) {
-                globalObject.throwValue(JSC.JSValue.c(exception.*));
-                return .zero;
             } else {
                 globalObject.throw("Expected session to be a string, Buffer or TypedArray", .{});
                 return .zero;
@@ -2769,7 +2734,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2827,7 +2792,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -2874,8 +2839,6 @@ fn NewSocket(comptime ssl: bool) type {
                 var arena: bun.ArenaAllocator = bun.ArenaAllocator.init(bun.default_allocator);
                 defer arena.deinit();
 
-                var exception_ref = [_]JSC.C.JSValueRef{null};
-                const exception: JSC.C.ExceptionRef = &exception_ref;
                 if (JSC.Node.StringOrBuffer.fromJS(globalObject, arena.allocator(), context_arg)) |sb| {
                     defer sb.deinit();
                     const context_slice = sb.slice();
@@ -2890,9 +2853,6 @@ fn NewSocket(comptime ssl: bool) type {
                         return .zero;
                     }
                     return buffer;
-                } else if (exception.* != null) {
-                    globalObject.throwValue(JSC.JSValue.c(exception.*));
-                    return .zero;
                 } else {
                     globalObject.throw("Expected context to be a string, Buffer or TypedArray", .{});
                     return .zero;
@@ -2915,7 +2875,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsNull();
             }
@@ -2981,7 +2941,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -3025,7 +2985,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -3053,7 +3013,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -3081,7 +3041,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             if (comptime ssl == false) {
                 return JSValue.jsNull();
@@ -3169,7 +3129,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             if (comptime ssl == false) {
                 return JSValue.jsNull();
@@ -3188,7 +3148,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             if (comptime ssl == false) {
                 return JSValue.jsBoolean(false);
@@ -3223,7 +3183,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
@@ -3274,7 +3234,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -3291,7 +3251,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             _: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -3307,7 +3267,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (comptime ssl == false) {
                 return JSValue.jsUndefined();
             }
@@ -3361,7 +3321,7 @@ fn NewSocket(comptime ssl: bool) type {
             this: *This,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             JSC.markBinding(@src());
             const this_js = callframe.this();
 
@@ -3378,7 +3338,6 @@ fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
-            var exception: JSC.C.JSValueRef = null;
             var success = false;
 
             const opts = args.ptr[0];
@@ -3395,17 +3354,7 @@ fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
-            const handlers = Handlers.fromJS(globalObject, socket_obj, &exception) orelse {
-                if (!globalObject.hasException() and exception != null) {
-                    globalObject.throwValue(exception.?.value());
-                }
-
-                return .zero;
-            };
-
-            if (!globalObject.hasException() and exception != null) {
-                globalObject.throwValue(exception.?.value());
-            }
+            const handlers = try Handlers.fromJS(globalObject, socket_obj);
 
             if (globalObject.hasException()) {
                 return .zero;
@@ -3420,24 +3369,18 @@ fn NewSocket(comptime ssl: bool) type {
                 }
             }
 
-            if (opts.getTruthy(globalObject, "tls")) |tls| {
+            if (try opts.getTruthy(globalObject, "tls")) |tls| {
                 if (tls.isBoolean()) {
                     if (tls.toBoolean()) {
                         ssl_opts = JSC.API.ServerConfig.SSLConfig.zero;
                     }
                 } else {
-                    if (JSC.API.ServerConfig.SSLConfig.inJS(JSC.VirtualMachine.get(), globalObject, tls, &exception)) |ssl_config| {
+                    if (try JSC.API.ServerConfig.SSLConfig.fromJS(JSC.VirtualMachine.get(), globalObject, tls)) |ssl_config| {
                         ssl_opts = ssl_config;
                     }
                 }
             }
 
-            if (exception != null) {
-                if (!globalObject.hasException()) {
-                    globalObject.throwValue(exception.?.value());
-                }
-            }
-
             if (globalObject.hasException()) {
                 return .zero;
             }
@@ -4274,23 +4217,21 @@ pub const WindowsNamedPipeContext = if (Environment.isWindows) struct {
     }
 } else void;
 
-pub fn jsAddServerName(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+pub fn jsAddServerName(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
     JSC.markBinding(@src());
 
     const arguments = callframe.arguments(3);
     if (arguments.len < 3) {
-        global.throwNotEnoughArguments("addServerName", 3, arguments.len);
-        return .zero;
+        return global.throwNotEnoughArguments("addServerName", 3, arguments.len);
     }
     const listener = arguments.ptr[0];
     if (listener.as(Listener)) |this| {
         return this.addServerName(global, arguments.ptr[1], arguments.ptr[2]);
     }
-    global.throw("Expected a Listener instance", .{});
-    return .zero;
+    return global.throw2("Expected a Listener instance", .{});
 }
 
-pub fn jsUpgradeDuplexToTLS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+pub fn jsUpgradeDuplexToTLS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
     JSC.markBinding(@src());
 
     const args = callframe.arguments(2);
@@ -4305,8 +4246,6 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.C
         return .zero;
     }
 
-    var exception: JSC.C.JSValueRef = null;
-
     const opts = args.ptr[1];
     if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
         globalObject.throw("Expected options object", .{});
@@ -4318,22 +4257,17 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.C
         return .zero;
     };
 
-    var handlers = Handlers.fromJS(globalObject, socket_obj, &exception) orelse {
-        globalObject.throwValue(exception.?.value());
-        return .zero;
-    };
+    var handlers = try Handlers.fromJS(globalObject, socket_obj);
 
     var ssl_opts: ?JSC.API.ServerConfig.SSLConfig = null;
-    if (opts.getTruthy(globalObject, "tls")) |tls| {
+    if (try opts.getTruthy(globalObject, "tls")) |tls| {
         if (tls.isBoolean()) {
             if (tls.toBoolean()) {
                 ssl_opts = JSC.API.ServerConfig.SSLConfig.zero;
             }
         } else {
-            if (JSC.API.ServerConfig.SSLConfig.inJS(JSC.VirtualMachine.get(), globalObject, tls, &exception)) |ssl_config| {
+            if (try JSC.API.ServerConfig.SSLConfig.fromJS(JSC.VirtualMachine.get(), globalObject, tls)) |ssl_config| {
                 ssl_opts = ssl_config;
-            } else if (exception != null) {
-                return .zero;
             }
         }
     }
@@ -4408,13 +4342,12 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.C
     return array;
 }
 
-pub fn jsIsNamedPipeSocket(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+pub fn jsIsNamedPipeSocket(global: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
     JSC.markBinding(@src());
 
     const arguments = callframe.arguments(3);
     if (arguments.len < 1) {
-        global.throwNotEnoughArguments("isNamedPipeSocket", 1, arguments.len);
-        return .zero;
+        return global.throwNotEnoughArguments("isNamedPipeSocket", 1, arguments.len);
     }
     const socket = arguments.ptr[0];
     if (socket.as(TCPSocket)) |this| {
@@ -4426,13 +4359,13 @@ pub fn jsIsNamedPipeSocket(global: *JSC.JSGlobalObject, callframe: *JSC.CallFram
 }
 pub fn createNodeTLSBinding(global: *JSC.JSGlobalObject) JSC.JSValue {
     return JSC.JSArray.create(global, &.{
-        JSC.JSFunction.create(global, "addServerName", JSC.toJSHostFunction(jsAddServerName), 3, .{}),
-        JSC.JSFunction.create(global, "upgradeDuplexToTLS", JSC.toJSHostFunction(jsUpgradeDuplexToTLS), 2, .{}),
-        JSC.JSFunction.create(global, "isNamedPipeSocket", JSC.toJSHostFunction(jsIsNamedPipeSocket), 1, .{}),
+        JSC.JSFunction.create(global, "addServerName", jsAddServerName, 3, .{}),
+        JSC.JSFunction.create(global, "upgradeDuplexToTLS", jsUpgradeDuplexToTLS, 2, .{}),
+        JSC.JSFunction.create(global, "isNamedPipeSocket", jsIsNamedPipeSocket, 1, .{}),
     });
 }
 
-pub fn jsCreateSocketPair(global: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+pub fn jsCreateSocketPair(global: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
     JSC.markBinding(@src());
 
     if (Environment.isWindows) {
diff --git a/src/bun.js/api/bun/subprocess.zig b/src/bun.js/api/bun/subprocess.zig
index 0488615ee91a05..4f0adb5e603423 100644
--- a/src/bun.js/api/bun/subprocess.zig
+++ b/src/bun.js/api/bun/subprocess.zig
@@ -41,13 +41,6 @@ pub const ResourceUsage = struct {
     pub usingnamespace JSC.Codegen.JSResourceUsage;
     rusage: Rusage,
 
-    pub fn constructor(
-        _: *JSC.JSGlobalObject,
-        _: *JSC.CallFrame,
-    ) ?*Subprocess {
-        return null;
-    }
-
     pub fn getCPUTime(
         this: *ResourceUsage,
         globalObject: *JSGlobalObject,
@@ -237,7 +230,7 @@ pub const Subprocess = struct {
         this: *Subprocess,
         globalObject: *JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return this.createResourceUsageObject(globalObject);
     }
 
@@ -393,11 +386,8 @@ pub const Subprocess = struct {
         this.updateHasPendingActivity();
     }
 
-    pub fn constructor(
-        _: *JSC.JSGlobalObject,
-        _: *JSC.CallFrame,
-    ) ?*Subprocess {
-        return null;
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*Subprocess {
+        return globalObject.throw2("Cannot construct Subprocess", .{});
     }
 
     const Readable = union(enum) {
@@ -592,7 +582,7 @@ pub const Subprocess = struct {
         this: *Subprocess,
         global: *JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.process.hasExited()) {
             // rely on GC to clean everything up in this case
             return .undefined;
@@ -620,7 +610,7 @@ pub const Subprocess = struct {
         this: *Subprocess,
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         this.this_jsvalue = callframe.this();
 
         var arguments = callframe.arguments(1);
@@ -654,7 +644,7 @@ pub const Subprocess = struct {
                 if (arguments.ptr[0].asString().length() == 0) {
                     break :brk SignalCode.default;
                 }
-                const signal_code = arguments.ptr[0].toEnum(globalThis, "signal", SignalCode) catch return .zero;
+                const signal_code = try arguments.ptr[0].toEnum(globalThis, "signal", SignalCode);
                 break :brk @intFromEnum(signal_code);
             } else if (!arguments.ptr[0].isEmptyOrUndefinedOrNull()) {
                 globalThis.throwInvalidArguments("Invalid signal: must be a string or an integer", .{});
@@ -700,12 +690,12 @@ pub const Subprocess = struct {
         this.process.close();
     }
 
-    pub fn doRef(this: *Subprocess, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn doRef(this: *Subprocess, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.jsRef();
         return .undefined;
     }
 
-    pub fn doUnref(this: *Subprocess, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn doUnref(this: *Subprocess, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.jsUnref();
         return .undefined;
     }
@@ -724,7 +714,7 @@ pub const Subprocess = struct {
         }
     }
 
-    pub fn doSend(this: *Subprocess, global: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSValue {
+    pub fn doSend(this: *Subprocess, global: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSValue {
         IPClog("Subprocess#doSend", .{});
         const ipc_data = &(this.ipc_data orelse {
             if (this.hasExited()) {
@@ -751,7 +741,7 @@ pub const Subprocess = struct {
         const ipc_data = this.ipc() orelse return;
         ipc_data.close(nextTick);
     }
-    pub fn disconnect(this: *Subprocess, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn disconnect(this: *Subprocess, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         _ = globalThis;
         _ = callframe;
         this.disconnectIPC(true);
@@ -1674,11 +1664,11 @@ pub const Subprocess = struct {
         return JSC.JSValue.jsNull();
     }
 
-    pub fn spawn(globalThis: *JSC.JSGlobalObject, args: JSValue, secondaryArgsValue: ?JSValue) JSValue {
+    pub fn spawn(globalThis: *JSC.JSGlobalObject, args: JSValue, secondaryArgsValue: ?JSValue) bun.JSError!JSValue {
         return spawnMaybeSync(globalThis, args, secondaryArgsValue, false);
     }
 
-    pub fn spawnSync(globalThis: *JSC.JSGlobalObject, args: JSValue, secondaryArgsValue: ?JSValue) JSValue {
+    pub fn spawnSync(globalThis: *JSC.JSGlobalObject, args: JSValue, secondaryArgsValue: ?JSValue) bun.JSError!JSValue {
         return spawnMaybeSync(globalThis, args, secondaryArgsValue, true);
     }
 
@@ -1687,7 +1677,7 @@ pub const Subprocess = struct {
         args_: JSValue,
         secondaryArgsValue: ?JSValue,
         comptime is_sync: bool,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         var arena = bun.ArenaAllocator.init(bun.default_allocator);
         defer arena.deinit();
         var allocator = arena.allocator();
@@ -1745,7 +1735,7 @@ pub const Subprocess = struct {
             } else if (!args.isObject()) {
                 globalThis.throwInvalidArguments("cmd must be an array", .{});
                 return .zero;
-            } else if (args.getTruthy(globalThis, "cmd")) |cmd_value_| {
+            } else if (try args.getTruthy(globalThis, "cmd")) |cmd_value_| {
                 cmd_value = cmd_value_;
             } else {
                 globalThis.throwInvalidArguments("cmd must be an array", .{});
@@ -1753,7 +1743,7 @@ pub const Subprocess = struct {
             }
 
             if (args.isObject()) {
-                if (args.getTruthy(globalThis, "argv0")) |argv0_| {
+                if (try args.getTruthy(globalThis, "argv0")) |argv0_| {
                     const argv0_str = argv0_.getZigString(globalThis);
                     if (argv0_str.len > 0) {
                         argv0 = argv0_str.toOwnedSliceZ(allocator) catch {
@@ -1764,7 +1754,7 @@ pub const Subprocess = struct {
                 }
 
                 // need to update `cwd` before searching for executable with `Which.which`
-                if (args.getTruthy(globalThis, "cwd")) |cwd_| {
+                if (try args.getTruthy(globalThis, "cwd")) |cwd_| {
                     const cwd_str = cwd_.getZigString(globalThis);
                     if (cwd_str.len > 0) {
                         cwd = cwd_str.toOwnedSliceZ(allocator) catch {
@@ -1849,10 +1839,10 @@ pub const Subprocess = struct {
             if (args != .zero and args.isObject()) {
                 // This must run before the stdio parsing happens
                 if (!is_sync) {
-                    if (args.getTruthy(globalThis, "ipc")) |val| {
+                    if (try args.getTruthy(globalThis, "ipc")) |val| {
                         if (val.isCell() and val.isCallable(globalThis.vm())) {
                             maybe_ipc_mode = ipc_mode: {
-                                if (args.getTruthy(globalThis, "serialization")) |mode_val| {
+                                if (try args.getTruthy(globalThis, "serialization")) |mode_val| {
                                     if (mode_val.isString()) {
                                         break :ipc_mode IPC.Mode.fromJS(globalThis, mode_val) orelse {
                                             if (!globalThis.hasException()) {
@@ -1875,7 +1865,7 @@ pub const Subprocess = struct {
                     }
                 }
 
-                if (args.getTruthy(globalThis, "signal")) |signal_val| {
+                if (try args.getTruthy(globalThis, "signal")) |signal_val| {
                     if (signal_val.as(JSC.WebCore.AbortSignal)) |signal| {
                         abort_signal = signal.ref();
                     } else {
@@ -1883,7 +1873,7 @@ pub const Subprocess = struct {
                     }
                 }
 
-                if (args.getTruthy(globalThis, "onDisconnect")) |onDisconnect_| {
+                if (try args.getTruthy(globalThis, "onDisconnect")) |onDisconnect_| {
                     if (!onDisconnect_.isCell() or !onDisconnect_.isCallable(globalThis.vm())) {
                         globalThis.throwInvalidArguments("onDisconnect must be a function or undefined", .{});
                         return .zero;
@@ -1895,7 +1885,7 @@ pub const Subprocess = struct {
                         onDisconnect_.withAsyncContextIfNeeded(globalThis);
                 }
 
-                if (args.getTruthy(globalThis, "onExit")) |onExit_| {
+                if (try args.getTruthy(globalThis, "onExit")) |onExit_| {
                     if (!onExit_.isCell() or !onExit_.isCallable(globalThis.vm())) {
                         globalThis.throwInvalidArguments("onExit must be a function or undefined", .{});
                         return .zero;
@@ -1907,7 +1897,7 @@ pub const Subprocess = struct {
                         onExit_.withAsyncContextIfNeeded(globalThis);
                 }
 
-                if (args.getTruthy(globalThis, "env")) |object| {
+                if (try args.getTruthy(globalThis, "env")) |object| {
                     if (!object.isObject()) {
                         globalThis.throwInvalidArguments("env must be an object", .{});
                         return .zero;
diff --git a/src/bun.js/api/bun/udp_socket.zig b/src/bun.js/api/bun/udp_socket.zig
index c8252ee664cccc..eadd4b245e604a 100644
--- a/src/bun.js/api/bun/udp_socket.zig
+++ b/src/bun.js/api/bun/udp_socket.zig
@@ -122,17 +122,15 @@ pub const UDPSocketConfig = struct {
     on_drain: JSValue = .zero,
     on_error: JSValue = .zero,
 
-    pub fn fromJS(globalThis: *JSGlobalObject, options: JSValue) ?This {
+    pub fn fromJS(globalThis: *JSGlobalObject, options: JSValue) bun.JSError!This {
         if (options.isEmptyOrUndefinedOrNull() or !options.isObject()) {
-            globalThis.throwInvalidArguments("Expected an object", .{});
-            return null;
+            return globalThis.throwInvalidArguments2("Expected an object", .{});
         }
 
         const hostname = brk: {
-            if (options.getTruthy(globalThis, "hostname")) |value| {
+            if (try options.getTruthy(globalThis, "hostname")) |value| {
                 if (!value.isString()) {
-                    globalThis.throwInvalidArguments("Expected \"hostname\" to be a string", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("Expected \"hostname\" to be a string", .{});
                 }
                 const str = value.toBunString(globalThis);
                 defer str.deref();
@@ -144,11 +142,10 @@ pub const UDPSocketConfig = struct {
         defer if (globalThis.hasException()) default_allocator.free(hostname);
 
         const port: u16 = brk: {
-            if (options.getTruthy(globalThis, "port")) |value| {
+            if (try options.getTruthy(globalThis, "port")) |value| {
                 const number = value.coerceToInt32(globalThis);
                 if (number < 0 or number > 0xffff) {
-                    globalThis.throwInvalidArguments("Expected \"port\" to be an integer between 0 and 65535", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("Expected \"port\" to be an integer between 0 and 65535", .{});
                 }
                 break :brk @intCast(number);
             } else {
@@ -161,29 +158,25 @@ pub const UDPSocketConfig = struct {
             .port = port,
         };
 
-        if (options.getTruthy(globalThis, "socket")) |socket| {
+        if (try options.getTruthy(globalThis, "socket")) |socket| {
             if (!socket.isObject()) {
-                globalThis.throwInvalidArguments("Expected \"socket\" to be an object", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Expected \"socket\" to be an object", .{});
             }
 
-            if (options.getTruthy(globalThis, "binaryType")) |value| {
+            if (try options.getTruthy(globalThis, "binaryType")) |value| {
                 if (!value.isString()) {
-                    globalThis.throwInvalidArguments("Expected \"socket.binaryType\" to be a string", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("Expected \"socket.binaryType\" to be a string", .{});
                 }
 
-                config.binary_type = JSC.BinaryType.fromJSValue(globalThis, value) orelse {
-                    globalThis.throwInvalidArguments("Expected \"socket.binaryType\" to be 'arraybuffer', 'uint8array', or 'buffer'", .{});
-                    return null;
+                config.binary_type = try JSC.BinaryType.fromJSValue(globalThis, value) orelse {
+                    return globalThis.throwInvalidArguments2("Expected \"socket.binaryType\" to be 'arraybuffer', 'uint8array', or 'buffer'", .{});
                 };
             }
 
             inline for (handlers) |handler| {
-                if (socket.getTruthyComptime(globalThis, handler.@"0")) |value| {
+                if (try socket.getTruthyComptime(globalThis, handler.@"0")) |value| {
                     if (!value.isCell() or !value.isCallable(globalThis.vm())) {
-                        globalThis.throwInvalidArguments("Expected \"socket.{s}\" to be a function", .{handler.@"0"});
-                        return null;
+                        return globalThis.throwInvalidArguments2("Expected \"socket.{s}\" to be a function", .{handler.@"0"});
                     }
                     @field(config, handler.@"1") = value;
                 }
@@ -198,25 +191,21 @@ pub const UDPSocketConfig = struct {
             }
         }
 
-        if (options.getTruthy(globalThis, "connect")) |connect| {
+        if (try options.getTruthy(globalThis, "connect")) |connect| {
             if (!connect.isObject()) {
-                globalThis.throwInvalidArguments("Expected \"connect\" to be an object", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Expected \"connect\" to be an object", .{});
             }
 
-            const connect_host_js = connect.getTruthy(globalThis, "hostname") orelse {
-                globalThis.throwInvalidArguments("Expected \"connect.hostname\" to be a string", .{});
-                return null;
+            const connect_host_js = try connect.getTruthy(globalThis, "hostname") orelse {
+                return globalThis.throwInvalidArguments2("Expected \"connect.hostname\" to be a string", .{});
             };
 
             if (!connect_host_js.isString()) {
-                globalThis.throwInvalidArguments("Expected \"connect.hostname\" to be a string", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Expected \"connect.hostname\" to be a string", .{});
             }
 
-            const connect_port_js = connect.getTruthy(globalThis, "port") orelse {
-                globalThis.throwInvalidArguments("Expected \"connect.port\" to be an integer", .{});
-                return null;
+            const connect_port_js = try connect.getTruthy(globalThis, "port") orelse {
+                return globalThis.throwInvalidArguments2("Expected \"connect.port\" to be an integer", .{});
             };
             const connect_port = connect_port_js.coerceToInt32(globalThis);
 
@@ -292,12 +281,10 @@ pub const UDPSocket = struct {
 
     pub usingnamespace bun.New(@This());
 
-    pub fn udpSocket(globalThis: *JSGlobalObject, options: JSValue) JSValue {
+    pub fn udpSocket(globalThis: *JSGlobalObject, options: JSValue) bun.JSError!JSValue {
         log("udpSocket", .{});
 
-        const config = UDPSocketConfig.fromJS(globalThis, options) orelse {
-            return .zero;
-        };
+        const config = try UDPSocketConfig.fromJS(globalThis, options);
 
         const vm = globalThis.bunVM();
         var this = This.new(.{
@@ -327,16 +314,14 @@ pub const UDPSocket = struct {
         )) |socket| {
             this.socket = socket;
         } else {
-            globalThis.throw("Failed to bind socket", .{});
-            return .zero;
+            return globalThis.throw2("Failed to bind socket", .{});
         }
 
         if (config.connect) |connect| {
             const ret = this.socket.connect(connect.address, connect.port);
             if (ret != 0) {
                 if (JSC.Maybe(void).errnoSys(ret, .connect)) |err| {
-                    globalThis.throwValue(err.toJS(globalThis));
-                    return .zero;
+                    return globalThis.throwValue2(err.toJS(globalThis));
                 }
             }
             this.connect_info = .{ .port = connect.port };
@@ -370,7 +355,7 @@ pub const UDPSocket = struct {
         return true;
     }
 
-    pub fn sendMany(this: *This, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn sendMany(this: *This, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         if (this.closed) {
             globalThis.throw("Socket is closed", .{});
             return .zero;
@@ -460,7 +445,7 @@ pub const UDPSocket = struct {
         this: *This,
         globalThis: *JSGlobalObject,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.closed) {
             globalThis.throw("Socket is closed", .{});
             return .zero;
@@ -563,7 +548,7 @@ pub const UDPSocket = struct {
         address: JSValue,
     };
 
-    pub fn ref(this: *This, globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn ref(this: *This, globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         if (!this.closed) {
             this.poll_ref.ref(globalThis.bunVM());
         }
@@ -571,7 +556,7 @@ pub const UDPSocket = struct {
         return .undefined;
     }
 
-    pub fn unref(this: *This, globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn unref(this: *This, globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.poll_ref.unref(globalThis.bunVM());
 
         return .undefined;
@@ -581,24 +566,21 @@ pub const UDPSocket = struct {
         this: *This,
         _: *JSGlobalObject,
         _: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (!this.closed) this.socket.close();
 
         return .undefined;
     }
 
-    pub fn reload(this: *This, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn reload(this: *This, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const args = callframe.arguments(1);
 
         if (args.len < 1) {
-            globalThis.throwInvalidArguments("Expected 1 argument", .{});
-            return .zero;
+            return globalThis.throwInvalidArguments2("Expected 1 argument", .{});
         }
 
         const options = args.ptr[0];
-        const config = UDPSocketConfig.fromJS(globalThis, options) orelse {
-            return .zero;
-        };
+        const config = try UDPSocketConfig.fromJS(globalThis, options);
 
         config.protect();
         var previous_config = this.config;
@@ -693,7 +675,7 @@ pub const UDPSocket = struct {
         this.destroy();
     }
 
-    pub fn jsConnect(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsConnect(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const args = callFrame.arguments(2);
 
         const this = callFrame.this().as(UDPSocket) orelse {
@@ -743,7 +725,7 @@ pub const UDPSocket = struct {
         return .undefined;
     }
 
-    pub fn jsDisconnect(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsDisconnect(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const this = callFrame.this().as(UDPSocket) orelse {
             globalObject.throwInvalidArguments("Expected UDPSocket as 'this'", .{});
             return .zero;
diff --git a/src/bun.js/api/bun/x509.zig b/src/bun.js/api/bun/x509.zig
index c5c63ddc9bbed6..18575daf44477b 100644
--- a/src/bun.js/api/bun/x509.zig
+++ b/src/bun.js/api/bun/x509.zig
@@ -6,7 +6,7 @@ const JSC = bun.JSC;
 const JSValue = JSC.JSValue;
 const JSGlobalObject = JSC.JSGlobalObject;
 
-fn x509GetNameObject(globalObject: *JSGlobalObject, name: ?*BoringSSL.X509_NAME) JSValue {
+fn x509GetNameObject(globalObject: *JSGlobalObject, name: ?*BoringSSL.X509_NAME) bun.JSError!JSValue {
     const cnt = BoringSSL.X509_NAME_entry_count(name);
     if (cnt <= 0) {
         return JSValue.jsUndefined();
@@ -54,7 +54,7 @@ fn x509GetNameObject(globalObject: *JSGlobalObject, name: ?*BoringSSL.X509_NAME)
         // change here without breaking things. Note that this creates nested data
         // structures, yet still does not allow representing Distinguished Names
         // accurately.
-        if (result.getTruthy(globalObject, name_slice)) |value| {
+        if (try result.getTruthy(globalObject, name_slice)) |value| {
             if (value.jsType().isArray()) {
                 value.push(globalObject, JSC.ZigString.fromUTF8(value_slice).toJS(globalObject));
             } else {
@@ -434,7 +434,7 @@ fn toUpper(slice: []u8) void {
     }
 }
 
-pub fn toJS(cert: *BoringSSL.X509, globalObject: *JSGlobalObject) JSValue {
+pub fn toJS(cert: *BoringSSL.X509, globalObject: *JSGlobalObject) bun.JSError!JSValue {
     const bio = BoringSSL.BIO_new(BoringSSL.BIO_s_mem()) orelse {
         globalObject.throw("Failed to create BIO", .{});
         return .zero;
@@ -444,9 +444,9 @@ pub fn toJS(cert: *BoringSSL.X509, globalObject: *JSGlobalObject) JSValue {
     // X509_check_ca() returns a range of values. Only 1 means "is a CA"
     const is_ca = BoringSSL.X509_check_ca(cert) == 1;
     const subject = BoringSSL.X509_get_subject_name(cert);
-    result.put(globalObject, ZigString.static("subject"), x509GetNameObject(globalObject, subject));
+    result.put(globalObject, ZigString.static("subject"), try x509GetNameObject(globalObject, subject));
     const issuer = BoringSSL.X509_get_issuer_name(cert);
-    result.put(globalObject, ZigString.static("issuer"), x509GetNameObject(globalObject, issuer));
+    result.put(globalObject, ZigString.static("issuer"), try x509GetNameObject(globalObject, issuer));
     result.put(globalObject, ZigString.static("subjectaltname"), x509GetSubjectAltNameString(globalObject, bio, cert));
     result.put(globalObject, ZigString.static("infoAccess"), x509GetInfoAccessString(globalObject, bio, cert));
     result.put(globalObject, ZigString.static("ca"), JSValue.jsBoolean(is_ca));
diff --git a/src/bun.js/api/ffi.zig b/src/bun.js/api/ffi.zig
index 4e83add58021ca..5c29b988b4d9a6 100644
--- a/src/bun.js/api/ffi.zig
+++ b/src/bun.js/api/ffi.zig
@@ -288,21 +288,33 @@ pub const FFI = struct {
                     }
                 }
             } else if (Environment.isLinux) {
+                // On Debian/Ubuntu, the lib and include paths are suffixed with {arch}-linux-gnu
+                // e.g. x86_64-linux-gnu or aarch64-linux-gnu
+                // On Alpine and RHEL-based distros, the paths are not suffixed
+
                 if (Environment.isX64) {
                     if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/include/x86_64-linux-gnu").isTrue()) {
                         cached_default_system_include_dir = "/usr/include/x86_64-linux-gnu";
+                    } else if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/include").isTrue()) {
+                        cached_default_system_include_dir = "/usr/include";
                     }
 
                     if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/lib/x86_64-linux-gnu").isTrue()) {
                         cached_default_system_library_dir = "/usr/lib/x86_64-linux-gnu";
+                    } else if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/lib64").isTrue()) {
+                        cached_default_system_library_dir = "/usr/lib64";
                     }
                 } else if (Environment.isAarch64) {
                     if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/include/aarch64-linux-gnu").isTrue()) {
                         cached_default_system_include_dir = "/usr/include/aarch64-linux-gnu";
+                    } else if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/include").isTrue()) {
+                        cached_default_system_include_dir = "/usr/include";
                     }
 
                     if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/lib/aarch64-linux-gnu").isTrue()) {
                         cached_default_system_library_dir = "/usr/lib/aarch64-linux-gnu";
+                    } else if (bun.sys.directoryExistsAt(std.fs.cwd(), "/usr/lib64").isTrue()) {
+                        cached_default_system_library_dir = "/usr/lib64";
                     }
                 }
             }
@@ -568,7 +580,7 @@ pub const FFI = struct {
                 bun.default_allocator.free(this.items);
         }
 
-        pub fn fromJSArray(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue, comptime property: []const u8) StringArray {
+        pub fn fromJSArray(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue, comptime property: []const u8) bun.JSError!StringArray {
             var iter = value.arrayIterator(globalThis);
             var items = std.ArrayList([:0]const u8).init(bun.default_allocator);
 
@@ -579,7 +591,7 @@ pub const FFI = struct {
                     }
                     items.deinit();
                     _ = globalThis.throwInvalidArgumentTypeValue(property, "array of strings", val);
-                    return .{};
+                    return error.JSError;
                 }
                 const str = val.getZigString(globalThis);
                 if (str.isEmpty()) continue;
@@ -589,11 +601,11 @@ pub const FFI = struct {
             return .{ .items = items.items };
         }
 
-        pub fn fromJSString(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue, comptime property: []const u8) StringArray {
+        pub fn fromJSString(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue, comptime property: []const u8) bun.JSError!StringArray {
             if (value == .undefined) return .{};
             if (!value.isString()) {
                 _ = globalThis.throwInvalidArgumentTypeValue(property, "array of strings", value);
-                return .{};
+                return error.JSError;
             }
             const str = value.getZigString(globalThis);
             if (str.isEmpty()) return .{};
@@ -602,7 +614,7 @@ pub const FFI = struct {
             return .{ .items = items.items };
         }
 
-        pub fn fromJS(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue, comptime property: []const u8) StringArray {
+        pub fn fromJS(globalThis: *JSC.JSGlobalObject, value: JSC.JSValue, comptime property: []const u8) bun.JSError!StringArray {
             if (value.isArray()) {
                 return fromJSArray(globalThis, value, property);
             }
@@ -610,10 +622,10 @@ pub const FFI = struct {
         }
     };
 
-    pub fn Bun__FFI__cc(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn Bun__FFI__cc(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(1).slice();
         if (arguments.len == 0 or !arguments[0].isObject()) {
-            return JSC.toInvalidArguments("Expected object", .{}, globalThis);
+            return globalThis.throwInvalidArguments2("Expected object", .{});
         }
 
         // Step 1. compile the user's code
@@ -630,32 +642,33 @@ pub const FFI = struct {
         const symbols_object = object.getOwn(globalThis, "symbols") orelse .undefined;
         if (!globalThis.hasException() and (symbols_object == .zero or !symbols_object.isObject())) {
             _ = globalThis.throwInvalidArgumentTypeValue("symbols", "object", symbols_object);
+            return error.JSError;
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
-        if (generateSymbols(globalThis, &compile_c.symbols.map, symbols_object) catch JSC.JSValue.zero) |val| {
+        if (try generateSymbols(globalThis, &compile_c.symbols.map, symbols_object)) |val| {
             if (val != .zero and !globalThis.hasException())
                 globalThis.throwValue(val);
-            return .zero;
+            return error.JSError;
         }
 
         if (compile_c.symbols.map.count() == 0) {
             globalThis.throw("Expected at least one exported symbol", .{});
-            return .zero;
+            return error.JSError;
         }
 
         if (object.getOwn(globalThis, "library")) |library_value| {
-            compile_c.libraries = StringArray.fromJS(globalThis, library_value, "library");
+            compile_c.libraries = try StringArray.fromJS(globalThis, library_value, "library");
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
-        if (object.getTruthy(globalThis, "flags")) |flags_value| {
+        if (try object.getTruthy(globalThis, "flags")) |flags_value| {
             if (flags_value.isArray()) {
                 var iter = flags_value.arrayIterator(globalThis);
 
@@ -689,10 +702,10 @@ pub const FFI = struct {
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
-        if (object.getTruthy(globalThis, "define")) |define_value| {
+        if (try object.getTruthy(globalThis, "define")) |define_value| {
             if (define_value.isObject()) {
                 const Iter = JSC.JSPropertyIterator(.{ .include_value = true, .skip_empty_name = true });
                 var iter = Iter.init(globalThis, define_value);
@@ -710,7 +723,7 @@ pub const FFI = struct {
                     }
                     if (globalThis.hasException()) {
                         bun.default_allocator.free(key);
-                        return .zero;
+                        return error.JSError;
                     }
 
                     compile_c.define.append(bun.default_allocator, .{ key, owned_value }) catch bun.outOfMemory();
@@ -719,15 +732,15 @@ pub const FFI = struct {
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
-        if (object.getTruthy(globalThis, "include")) |include_value| {
-            compile_c.include_dirs = StringArray.fromJS(globalThis, include_value, "include");
+        if (try object.getTruthy(globalThis, "include")) |include_value| {
+            compile_c.include_dirs = try StringArray.fromJS(globalThis, include_value, "include");
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
         if (object.getOwn(globalThis, "source")) |source_value| {
@@ -749,7 +762,7 @@ pub const FFI = struct {
         }
 
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
         // Now we compile the code with tinycc.
@@ -766,14 +779,14 @@ pub const FFI = struct {
                     }
 
                     globalThis.throw("{s}", .{combined.items});
-                    return .zero;
+                    return error.JSError;
                 },
                 error.JSException => {
-                    return .zero;
+                    return error.JSError;
                 },
                 error.OutOfMemory => {
                     globalThis.throwOutOfMemory();
-                    return .zero;
+                    return error.JSError;
                 },
             }
         };
@@ -800,17 +813,17 @@ pub const FFI = struct {
                     globalThis.throwValue(ret);
                 }
 
-                return .zero;
+                return error.JSError;
             };
             switch (function.step) {
                 .failed => |err| {
                     const res = ZigString.init(err.msg).toErrorInstance(globalThis);
                     globalThis.throwValue(res);
-                    return .zero;
+                    return error.JSError;
                 },
                 .pending => {
                     globalThis.throw("Failed to compile (nothing happend!)", .{});
-                    return .zero;
+                    return error.JSError;
                 },
                 .compiled => |*compiled| {
                     const str = ZigString.init(bun.asByteSlice(function_name));
@@ -903,7 +916,7 @@ pub const FFI = struct {
         this: *FFI,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) callconv(.C) JSValue {
+    ) bun.JSError!JSValue {
         JSC.markBinding(@src());
         if (this.closed) {
             return .undefined;
@@ -1296,7 +1309,7 @@ pub const FFI = struct {
         JSC.Codegen.JSFFI.symbolsValueSetCached(js_object, global, obj);
         return js_object;
     }
-    pub fn generateSymbolForFunction(global: *JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, function: *Function) !?JSValue {
+    pub fn generateSymbolForFunction(global: *JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, function: *Function) bun.JSError!?JSValue {
         JSC.markBinding(@src());
 
         var abi_types = std.ArrayListUnmanaged(ABIType){};
@@ -1347,11 +1360,11 @@ pub const FFI = struct {
 
         var threadsafe = false;
 
-        if (value.getTruthy(global, "threadsafe")) |threadsafe_value| {
+        if (try value.getTruthy(global, "threadsafe")) |threadsafe_value| {
             threadsafe = threadsafe_value.toBoolean();
         }
 
-        if (value.getTruthy(global, "returns")) |ret_value| brk: {
+        if (try value.getTruthy(global, "returns")) |ret_value| brk: {
             if (ret_value.isAnyInt()) {
                 const int = ret_value.toInt32();
                 switch (int) {
@@ -1411,7 +1424,8 @@ pub const FFI = struct {
 
         return null;
     }
-    pub fn generateSymbols(global: *JSGlobalObject, symbols: *bun.StringArrayHashMapUnmanaged(Function), object: JSC.JSValue) !?JSValue {
+
+    pub fn generateSymbols(global: *JSGlobalObject, symbols: *bun.StringArrayHashMapUnmanaged(Function), object: JSC.JSValue) bun.JSError!?JSValue {
         JSC.markBinding(@src());
         const allocator = VirtualMachine.get().allocator;
 
diff --git a/src/bun.js/api/filesystem_router.classes.ts b/src/bun.js/api/filesystem_router.classes.ts
index 4c331f7de9a72d..99ec5c56c4673b 100644
--- a/src/bun.js/api/filesystem_router.classes.ts
+++ b/src/bun.js/api/filesystem_router.classes.ts
@@ -32,6 +32,25 @@ export default [
     klass: {},
   }),
 
+  define({
+    name: "FrameworkFileSystemRouter",
+    construct: true,
+    finalize: true,
+    JSType: "0b11101110",
+    configurable: false,
+    proto: {
+      toJSON: {
+        fn: "toJSON",
+        length: 0,
+      },
+      match: {
+        fn: "match",
+        length: 1,
+      },
+    },
+    klass: {},
+  }),
+
   define({
     name: "MatchedRoute",
     noConstructor: true,
diff --git a/src/bun.js/api/filesystem_router.zig b/src/bun.js/api/filesystem_router.zig
index 3083c98bdcae4b..b6352f84b9a80b 100644
--- a/src/bun.js/api/filesystem_router.zig
+++ b/src/bun.js/api/filesystem_router.zig
@@ -49,17 +49,15 @@ pub const FileSystemRouter = struct {
 
     pub usingnamespace JSC.Codegen.JSFileSystemRouter;
 
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*FileSystemRouter {
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*FileSystemRouter {
         const argument_ = callframe.arguments(1);
         if (argument_.len == 0) {
-            globalThis.throwInvalidArguments("Expected object", .{});
-            return null;
+            return globalThis.throwInvalidArguments2("Expected object", .{});
         }
 
         const argument = argument_.ptr[0];
         if (argument.isEmptyOrUndefinedOrNull() or !argument.isObject()) {
-            globalThis.throwInvalidArguments("Expected object", .{});
-            return null;
+            return globalThis.throwInvalidArguments2("Expected object", .{});
         }
         var vm = globalThis.bunVM();
 
@@ -71,18 +69,15 @@ pub const FileSystemRouter = struct {
         var out_buf: [bun.MAX_PATH_BYTES * 2]u8 = undefined;
         if (argument.get(globalThis, "style")) |style_val| {
             if (!style_val.getZigString(globalThis).eqlComptime("nextjs")) {
-                globalThis.throwInvalidArguments("Only 'nextjs' style is currently implemented", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Only 'nextjs' style is currently implemented", .{});
             }
         } else {
-            globalThis.throwInvalidArguments("Expected 'style' option (ex: \"style\": \"nextjs\")", .{});
-            return null;
+            return globalThis.throwInvalidArguments2("Expected 'style' option (ex: \"style\": \"nextjs\")", .{});
         }
 
         if (argument.get(globalThis, "dir")) |dir| {
             if (!dir.isString()) {
-                globalThis.throwInvalidArguments("Expected dir to be a string", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("Expected dir to be a string", .{});
             }
             const root_dir_path_ = dir.toSlice(globalThis, globalThis.allocator());
             if (!(root_dir_path_.len == 0 or strings.eqlComptime(root_dir_path_.slice(), "."))) {
@@ -97,8 +92,7 @@ pub const FileSystemRouter = struct {
             }
         } else {
             // dir is not optional
-            globalThis.throwInvalidArguments("Expected dir to be a string", .{});
-            return null;
+            return globalThis.throwInvalidArguments2("Expected dir to be a string", .{});
         }
         var arena = globalThis.allocator().create(bun.ArenaAllocator) catch unreachable;
         arena.* = bun.ArenaAllocator.init(globalThis.allocator());
@@ -106,35 +100,32 @@ pub const FileSystemRouter = struct {
         var extensions = std.ArrayList(string).init(allocator);
         if (argument.get(globalThis, "fileExtensions")) |file_extensions| {
             if (!file_extensions.jsType().isArray()) {
-                globalThis.throwInvalidArguments("Expected fileExtensions to be an Array", .{});
                 origin_str.deinit();
                 arena.deinit();
                 globalThis.allocator().destroy(arena);
-                return null;
+                return globalThis.throwInvalidArguments2("Expected fileExtensions to be an Array", .{});
             }
 
             var iter = file_extensions.arrayIterator(globalThis);
             extensions.ensureTotalCapacityPrecise(iter.len) catch unreachable;
             while (iter.next()) |val| {
                 if (!val.isString()) {
-                    globalThis.throwInvalidArguments("Expected fileExtensions to be an Array of strings", .{});
                     origin_str.deinit();
                     arena.deinit();
                     globalThis.allocator().destroy(arena);
-                    return null;
+                    return globalThis.throwInvalidArguments2("Expected fileExtensions to be an Array of strings", .{});
                 }
                 if (val.getLength(globalThis) == 0) continue;
                 extensions.appendAssumeCapacity((val.toSlice(globalThis, allocator).clone(allocator) catch unreachable).slice()[1..]);
             }
         }
 
-        if (argument.getTruthy(globalThis, "assetPrefix")) |asset_prefix| {
+        if (try argument.getTruthy(globalThis, "assetPrefix")) |asset_prefix| {
             if (!asset_prefix.isString()) {
-                globalThis.throwInvalidArguments("Expected assetPrefix to be a string", .{});
                 origin_str.deinit();
                 arena.deinit();
                 globalThis.allocator().destroy(arena);
-                return null;
+                return globalThis.throwInvalidArguments2("Expected assetPrefix to be a string", .{});
             }
 
             asset_prefix_slice = asset_prefix.toSlice(globalThis, allocator).clone(allocator) catch unreachable;
@@ -147,17 +138,15 @@ pub const FileSystemRouter = struct {
         const path_to_use = (root_dir_path.cloneWithTrailingSlash(allocator) catch unreachable).slice();
 
         const root_dir_info = vm.bundler.resolver.readDirInfo(path_to_use) catch {
-            globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "reading root directory"));
             origin_str.deinit();
             arena.deinit();
             globalThis.allocator().destroy(arena);
-            return null;
+            return globalThis.throwValue2(log.toJS(globalThis, globalThis.allocator(), "reading root directory"));
         } orelse {
-            globalThis.throw("Unable to find directory: {s}", .{root_dir_path.slice()});
             origin_str.deinit();
             arena.deinit();
             globalThis.allocator().destroy(arena);
-            return null;
+            return globalThis.throw2("Unable to find directory: {s}", .{root_dir_path.slice()});
         };
 
         var router = Router.init(vm.bundler.fs, allocator, .{
@@ -167,29 +156,26 @@ pub const FileSystemRouter = struct {
         }) catch unreachable;
 
         router.loadRoutes(&log, root_dir_info, Resolver, &vm.bundler.resolver, router.config.dir) catch {
-            globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
             origin_str.deinit();
             arena.deinit();
             globalThis.allocator().destroy(arena);
-            return null;
+            return globalThis.throwValue2(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
         };
 
         if (argument.get(globalThis, "origin")) |origin| {
             if (!origin.isString()) {
-                globalThis.throwInvalidArguments("Expected origin to be a string", .{});
                 arena.deinit();
                 globalThis.allocator().destroy(arena);
-                return null;
+                return globalThis.throwInvalidArguments2("Expected origin to be a string", .{});
             }
             origin_str = origin.toSlice(globalThis, globalThis.allocator());
         }
 
         if (log.errors + log.warnings > 0) {
-            globalThis.throwValue(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
             origin_str.deinit();
             arena.deinit();
             globalThis.allocator().destroy(arena);
-            return null;
+            return globalThis.throwValue2(log.toJS(globalThis, globalThis.allocator(), "loading routes"));
         }
 
         var fs_router = globalThis.allocator().create(FileSystemRouter) catch unreachable;
@@ -211,7 +197,7 @@ pub const FileSystemRouter = struct {
         return fs_router;
     }
 
-    pub fn reload(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn reload(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const this_value = callframe.this();
 
         var arena = globalThis.allocator().create(bun.ArenaAllocator) catch unreachable;
@@ -259,7 +245,7 @@ pub const FileSystemRouter = struct {
         return this_value;
     }
 
-    pub fn match(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn match(this: *FileSystemRouter, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const argument_ = callframe.arguments(2);
         if (argument_.len == 0) {
             globalThis.throwInvalidArguments("Expected string, Request or Response", .{});
@@ -531,11 +517,10 @@ pub const MatchedRoute = struct {
                         for (entry.values, 0..) |value, i| {
                             values[i] = ZigString.init(value).withEncoding();
                         }
-                        obj.putRecord(global, &str, values.ptr, values.len);
+                        obj.putRecord(global, &str, values);
                     } else {
                         query_string_value_refs_buf[0] = ZigString.init(entry.values[0]).withEncoding();
-
-                        obj.putRecord(global, &str, &query_string_value_refs_buf, 1);
+                        obj.putRecord(global, &str, query_string_value_refs_buf[0..1]);
                     }
                 }
             }
diff --git a/src/bun.js/api/glob.zig b/src/bun.js/api/glob.zig
index 122aff963b989a..784ec5b63d974d 100644
--- a/src/bun.js/api/glob.zig
+++ b/src/bun.js/api/glob.zig
@@ -39,7 +39,7 @@ const ScanOpts = struct {
     follow_symlinks: bool,
     error_on_broken_symlinks: bool,
 
-    fn parseCWD(globalThis: *JSGlobalObject, allocator: std.mem.Allocator, cwdVal: JSC.JSValue, absolute: bool, comptime fnName: string) ?[]const u8 {
+    fn parseCWD(globalThis: *JSGlobalObject, allocator: std.mem.Allocator, cwdVal: JSC.JSValue, absolute: bool, comptime fnName: string) bun.JSError![]const u8 {
         const cwd_str_raw = cwdVal.toSlice(globalThis, allocator);
         if (cwd_str_raw.len == 0) return "";
 
@@ -48,7 +48,7 @@ const ScanOpts = struct {
             if (ResolvePath.Platform.auto.isAbsolute(cwd_str_raw.slice())) {
                 const cwd_str = cwd_str_raw.clone(allocator) catch {
                     globalThis.throwOutOfMemory();
-                    return null;
+                    return error.JSError;
                 };
                 break :cwd_str cwd_str.ptr[0..cwd_str.len];
             }
@@ -59,7 +59,7 @@ const ScanOpts = struct {
                 const cwd_str = ResolvePath.joinStringBuf(&path_buf2, &[_][]const u8{cwd_str_raw.slice()}, .auto);
                 break :cwd_str allocator.dupe(u8, cwd_str) catch {
                     globalThis.throwOutOfMemory();
-                    return null;
+                    return error.JSError;
                 };
             }
 
@@ -69,8 +69,7 @@ const ScanOpts = struct {
                 .result => |cwd| cwd,
                 .err => |err| {
                     const errJs = err.toJSC(globalThis);
-                    globalThis.throwValue(errJs);
-                    return null;
+                    return globalThis.throwValue2(errJs);
                 },
             };
 
@@ -81,19 +80,18 @@ const ScanOpts = struct {
 
             break :cwd_str allocator.dupe(u8, cwd_str) catch {
                 globalThis.throwOutOfMemory();
-                return null;
+                return error.JSError;
             };
         };
 
         if (cwd_str.len > bun.MAX_PATH_BYTES) {
-            globalThis.throw("{s}: invalid `cwd`, longer than {d} bytes", .{ fnName, bun.MAX_PATH_BYTES });
-            return null;
+            return globalThis.throw2("{s}: invalid `cwd`, longer than {d} bytes", .{ fnName, bun.MAX_PATH_BYTES });
         }
 
         return cwd_str;
     }
 
-    fn fromJS(globalThis: *JSGlobalObject, arguments: *ArgumentsSlice, comptime fnName: []const u8, arena: *Arena) ?ScanOpts {
+    fn fromJS(globalThis: *JSGlobalObject, arguments: *ArgumentsSlice, comptime fnName: []const u8, arena: *Arena) bun.JSError!?ScanOpts {
         const optsObj: JSValue = arguments.nextEat() orelse return null;
         var out: ScanOpts = .{
             .cwd = null,
@@ -106,13 +104,11 @@ const ScanOpts = struct {
         if (optsObj.isUndefinedOrNull()) return out;
         if (!optsObj.isObject()) {
             if (optsObj.isString()) {
-                if (parseCWD(globalThis, arena.allocator(), optsObj, out.absolute, fnName)) |result| {
+                {
+                    const result = try parseCWD(globalThis, arena.allocator(), optsObj, out.absolute, fnName);
                     if (result.len > 0) {
                         out.cwd = result;
                     }
-                } else {
-                    // error
-                    return null;
                 }
                 return out;
             }
@@ -120,39 +116,37 @@ const ScanOpts = struct {
             return null;
         }
 
-        if (optsObj.getTruthy(globalThis, "onlyFiles")) |only_files| {
+        if (try optsObj.getTruthy(globalThis, "onlyFiles")) |only_files| {
             out.only_files = if (only_files.isBoolean()) only_files.asBoolean() else false;
         }
 
-        if (optsObj.getTruthy(globalThis, "throwErrorOnBrokenSymlink")) |error_on_broken| {
+        if (try optsObj.getTruthy(globalThis, "throwErrorOnBrokenSymlink")) |error_on_broken| {
             out.error_on_broken_symlinks = if (error_on_broken.isBoolean()) error_on_broken.asBoolean() else false;
         }
 
-        if (optsObj.getTruthy(globalThis, "followSymlinks")) |followSymlinksVal| {
+        if (try optsObj.getTruthy(globalThis, "followSymlinks")) |followSymlinksVal| {
             out.follow_symlinks = if (followSymlinksVal.isBoolean()) followSymlinksVal.asBoolean() else false;
         }
 
-        if (optsObj.getTruthy(globalThis, "absolute")) |absoluteVal| {
+        if (try optsObj.getTruthy(globalThis, "absolute")) |absoluteVal| {
             out.absolute = if (absoluteVal.isBoolean()) absoluteVal.asBoolean() else false;
         }
 
-        if (optsObj.getTruthy(globalThis, "cwd")) |cwdVal| {
+        if (try optsObj.getTruthy(globalThis, "cwd")) |cwdVal| {
             if (!cwdVal.isString()) {
                 globalThis.throw("{s}: invalid `cwd`, not a string", .{fnName});
                 return null;
             }
 
-            if (parseCWD(globalThis, arena.allocator(), cwdVal, out.absolute, fnName)) |result| {
+            {
+                const result = try parseCWD(globalThis, arena.allocator(), cwdVal, out.absolute, fnName);
                 if (result.len > 0) {
                     out.cwd = result;
                 }
-            } else {
-                // error
-                return null;
             }
         }
 
-        if (optsObj.getTruthy(globalThis, "dot")) |dot| {
+        if (try optsObj.getTruthy(globalThis, "dot")) |dot| {
             out.dot = if (dot.isBoolean()) dot.asBoolean() else false;
         }
 
@@ -248,8 +242,8 @@ fn makeGlobWalker(
     comptime fnName: []const u8,
     alloc: Allocator,
     arena: *Arena,
-) ?*GlobWalker {
-    const matchOpts = ScanOpts.fromJS(globalThis, arguments, fnName, arena) orelse return null;
+) bun.JSError!?*GlobWalker {
+    const matchOpts = try ScanOpts.fromJS(globalThis, arguments, fnName, arena) orelse return null;
     const cwd = matchOpts.cwd;
     const dot = matchOpts.dot;
     const absolute = matchOpts.absolute;
@@ -260,7 +254,7 @@ fn makeGlobWalker(
     if (cwd != null) {
         var globWalker = alloc.create(GlobWalker) catch {
             globalThis.throwOutOfMemory();
-            return null;
+            return error.JSError;
         };
 
         globWalker.* = .{};
@@ -276,11 +270,10 @@ fn makeGlobWalker(
             only_files,
         ) catch {
             globalThis.throwOutOfMemory();
-            return null;
+            return error.JSError;
         }) {
             .err => |err| {
-                globalThis.throwValue(err.toJSC(globalThis));
-                return null;
+                return globalThis.throwValue2(err.toJSC(globalThis));
             },
             else => {},
         }
@@ -288,7 +281,7 @@ fn makeGlobWalker(
     }
     var globWalker = alloc.create(GlobWalker) catch {
         globalThis.throwOutOfMemory();
-        return null;
+        return error.JSError;
     };
 
     globWalker.* = .{};
@@ -302,11 +295,10 @@ fn makeGlobWalker(
         only_files,
     ) catch {
         globalThis.throwOutOfMemory();
-        return null;
+        return error.JSError;
     }) {
         .err => |err| {
-            globalThis.throwValue(err.toJSC(globalThis));
-            return null;
+            return globalThis.throwValue2(err.toJSC(globalThis));
         },
         else => {},
     }
@@ -314,26 +306,21 @@ fn makeGlobWalker(
     return globWalker;
 }
 
-pub fn constructor(
-    globalThis: *JSC.JSGlobalObject,
-    callframe: *JSC.CallFrame,
-) ?*Glob {
+pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Glob {
     const alloc = getAllocator(globalThis);
 
     const arguments_ = callframe.arguments(1);
     var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
     defer arguments.deinit();
-    const pat_arg = arguments.nextEat() orelse {
-        globalThis.throw("Glob.constructor: expected 1 arguments, got 0", .{});
-        return null;
+    const pat_arg: JSValue = arguments.nextEat() orelse {
+        return globalThis.throw2("Glob.constructor: expected 1 arguments, got 0", .{});
     };
 
     if (!pat_arg.isString()) {
-        globalThis.throw("Glob.constructor: first argument is not a string", .{});
-        return null;
+        return globalThis.throw2("Glob.constructor: first argument is not a string", .{});
     }
 
-    const pat_str: []u8 = @constCast((pat_arg.toSliceClone(globalThis) orelse return null).slice());
+    const pat_str: []u8 = @constCast((pat_arg.toSliceClone(globalThis) orelse return error.JSError).slice());
 
     const all_ascii = isAllAscii(pat_str);
 
@@ -341,16 +328,10 @@ pub fn constructor(
     glob.* = .{ .pattern = pat_str, .is_ascii = all_ascii };
 
     if (!all_ascii) {
-        var codepoints = std.ArrayList(u32).initCapacity(alloc, glob.pattern.len * 2) catch {
-            globalThis.throwOutOfMemory();
-            return null;
-        };
+        var codepoints = try std.ArrayList(u32).initCapacity(alloc, glob.pattern.len * 2);
         errdefer codepoints.deinit();
 
-        convertUtf8(&codepoints, glob.pattern) catch {
-            globalThis.throwOutOfMemory();
-            return null;
-        };
+        try convertUtf8(&codepoints, glob.pattern);
 
         glob.pattern_codepoints = codepoints;
     }
@@ -384,7 +365,7 @@ fn decrPendingActivityFlag(has_pending_activity: *std.atomic.Value(usize)) void
     _ = has_pending_activity.fetchSub(1, .seq_cst);
 }
 
-pub fn __scan(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn __scan(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const alloc = getAllocator(globalThis);
 
     const arguments_ = callframe.arguments(1);
@@ -392,7 +373,7 @@ pub fn __scan(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFram
     defer arguments.deinit();
 
     var arena = std.heap.ArenaAllocator.init(alloc);
-    const globWalker = this.makeGlobWalker(globalThis, &arguments, "scan", alloc, &arena) orelse {
+    const globWalker = try this.makeGlobWalker(globalThis, &arguments, "scan", alloc, &arena) orelse {
         arena.deinit();
         return .undefined;
     };
@@ -401,14 +382,14 @@ pub fn __scan(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFram
     var task = WalkTask.create(globalThis, alloc, globWalker, &this.has_pending_activity) catch {
         decrPendingActivityFlag(&this.has_pending_activity);
         globalThis.throwOutOfMemory();
-        return .undefined;
+        return error.JSError;
     };
     task.schedule();
 
     return task.promise.value();
 }
 
-pub fn __scanSync(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn __scanSync(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const alloc = getAllocator(globalThis);
 
     const arguments_ = callframe.arguments(1);
@@ -416,7 +397,7 @@ pub fn __scanSync(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.Call
     defer arguments.deinit();
 
     var arena = std.heap.ArenaAllocator.init(alloc);
-    var globWalker = this.makeGlobWalker(globalThis, &arguments, "scanSync", alloc, &arena) orelse {
+    var globWalker = try this.makeGlobWalker(globalThis, &arguments, "scanSync", alloc, &arena) orelse {
         arena.deinit();
         return .undefined;
     };
@@ -424,11 +405,10 @@ pub fn __scanSync(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.Call
 
     switch (globWalker.walk() catch {
         globalThis.throwOutOfMemory();
-        return .undefined;
+        return error.JSError;
     }) {
         .err => |err| {
-            globalThis.throwValue(err.toJSC(globalThis));
-            return JSValue.undefined;
+            return globalThis.throwValue2(err.toJSC(globalThis));
         },
         .result => {},
     }
@@ -438,7 +418,7 @@ pub fn __scanSync(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.Call
     return matchedPaths;
 }
 
-pub fn match(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn match(this: *Glob, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const alloc = getAllocator(globalThis);
     var arena = Arena.init(alloc);
     defer arena.deinit();
diff --git a/src/bun.js/api/html_rewriter.zig b/src/bun.js/api/html_rewriter.zig
index 767662975c9a20..7b2b4931f8cb2c 100644
--- a/src/bun.js/api/html_rewriter.zig
+++ b/src/bun.js/api/html_rewriter.zig
@@ -48,7 +48,7 @@ pub const HTMLRewriter = struct {
 
     pub usingnamespace JSC.Codegen.JSHTMLRewriter;
 
-    pub fn constructor(_: *JSGlobalObject, _: *JSC.CallFrame) callconv(.C) ?*HTMLRewriter {
+    pub fn constructor(_: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*HTMLRewriter {
         const rewriter = bun.default_allocator.create(HTMLRewriter) catch bun.outOfMemory();
         rewriter.* = HTMLRewriter{
             .builder = LOLHTML.HTMLRewriter.Builder.init(),
@@ -64,12 +64,12 @@ pub const HTMLRewriter = struct {
         selector_name: ZigString,
         callFrame: *JSC.CallFrame,
         listener: JSValue,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const selector_slice = std.fmt.allocPrint(bun.default_allocator, "{}", .{selector_name}) catch bun.outOfMemory();
 
         var selector = LOLHTML.HTMLSelector.parse(selector_slice) catch
             return throwLOLHTMLError(global);
-        const handler_ = ElementHandler.init(global, listener) catch return .zero;
+        const handler_ = try ElementHandler.init(global, listener);
         const handler = getAllocator(global).create(ElementHandler) catch bun.outOfMemory();
         handler.* = handler_;
 
@@ -111,8 +111,8 @@ pub const HTMLRewriter = struct {
         global: *JSGlobalObject,
         listener: JSValue,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
-        const handler_ = DocumentHandler.init(global, listener) catch return .zero;
+    ) bun.JSError!JSValue {
+        const handler_ = try DocumentHandler.init(global, listener);
 
         const handler = getAllocator(global).create(DocumentHandler) catch bun.outOfMemory();
         handler.* = handler_;
@@ -198,7 +198,8 @@ pub const HTMLRewriter = struct {
         };
 
         if (kind != .other) {
-            if (JSC.WebCore.Body.extract(global, response_value)) |body_value| {
+            {
+                const body_value = JSC.WebCore.Body.extract(global, response_value) catch return .zero;
                 const resp = bun.new(Response, Response{
                     .init = .{
                         .status_code = 200,
@@ -776,11 +777,8 @@ const DocumentHandler = struct {
         };
 
         if (!thisObject.isObject()) {
-            global.throwInvalidArguments(
-                "Expected object",
-                .{},
-            );
-            return error.InvalidArguments;
+            global.throwInvalidArguments("Expected object", .{});
+            return error.JSError;
         }
 
         errdefer {
@@ -804,7 +802,7 @@ const DocumentHandler = struct {
         if (thisObject.get(global, "doctype")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("doctype must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onDocTypeCallback = val;
@@ -813,7 +811,7 @@ const DocumentHandler = struct {
         if (thisObject.get(global, "comments")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("comments must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onCommentCallback = val;
@@ -822,7 +820,7 @@ const DocumentHandler = struct {
         if (thisObject.get(global, "text")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("text must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onTextCallback = val;
@@ -831,7 +829,7 @@ const DocumentHandler = struct {
         if (thisObject.get(global, "end")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("end must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onEndCallback = val;
@@ -935,17 +933,14 @@ const ElementHandler = struct {
         }
 
         if (!thisObject.isObject()) {
-            global.throwInvalidArguments(
-                "Expected object",
-                .{},
-            );
-            return error.InvalidArguments;
+            global.throwInvalidArguments("Expected object", .{});
+            return error.JSError;
         }
 
         if (thisObject.get(global, "element")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("element must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onElementCallback = val;
@@ -954,7 +949,7 @@ const ElementHandler = struct {
         if (thisObject.get(global, "comments")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("comments must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onCommentCallback = val;
@@ -963,7 +958,7 @@ const ElementHandler = struct {
         if (thisObject.get(global, "text")) |val| {
             if (val.isUndefinedOrNull() or !val.isCell() or !val.isCallable(global.vm())) {
                 global.throwInvalidArguments("text must be a function", .{});
-                return error.InvalidArguments;
+                return error.JSError;
             }
             val.protect();
             handler.onTextCallback = val;
@@ -1096,7 +1091,7 @@ pub const TextChunk = struct {
         this: *TextChunk,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.text_chunk == null)
             return JSValue.jsUndefined();
         this.text_chunk.?.remove();
@@ -1278,7 +1273,7 @@ pub const Comment = struct {
         this: *Comment,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.comment == null)
             return JSValue.jsNull();
         this.comment.?.remove();
@@ -1400,7 +1395,7 @@ pub const EndTag = struct {
         this: *EndTag,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.end_tag == null)
             return JSValue.jsUndefined();
 
@@ -1449,7 +1444,7 @@ pub const AttributeIterator = struct {
 
     pub usingnamespace JSC.Codegen.JSAttributeIterator;
 
-    pub fn next(this: *AttributeIterator, globalObject: *JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn next(this: *AttributeIterator, globalObject: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         const done_label = JSC.ZigString.static("done");
         const value_label = JSC.ZigString.static("value");
 
@@ -1475,7 +1470,7 @@ pub const AttributeIterator = struct {
         ));
     }
 
-    pub fn getThis(_: *AttributeIterator, _: *JSGlobalObject, callFrame: *JSC.CallFrame) JSValue {
+    pub fn getThis(_: *AttributeIterator, _: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSValue {
         return callFrame.this();
     }
 };
@@ -1494,7 +1489,7 @@ pub const Element = struct {
         globalObject: *JSGlobalObject,
         function: JSValue,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.element == null)
             return JSValue.jsNull();
         if (function.isUndefinedOrNull() or !function.isCallable(globalObject.vm())) {
@@ -1674,7 +1669,7 @@ pub const Element = struct {
         this: *Element,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.element == null)
             return JSValue.jsUndefined();
 
@@ -1687,7 +1682,7 @@ pub const Element = struct {
         this: *Element,
         _: *JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         if (this.element == null)
             return JSValue.jsUndefined();
 
diff --git a/src/bun.js/api/postgres.classes.ts b/src/bun.js/api/postgres.classes.ts
index ddb27007c7d03f..04097296fc83a5 100644
--- a/src/bun.js/api/postgres.classes.ts
+++ b/src/bun.js/api/postgres.classes.ts
@@ -59,7 +59,7 @@ export default [
         length: 0,
       },
     },
-    values: ["pendingValue", "binding"],
+    values: ["pendingValue", "columns", "binding"],
     estimatedSize: true,
   }),
 ];
diff --git a/src/bun.js/api/server.zig b/src/bun.js/api/server.zig
index b3a19337344da6..307c84d87ffcf2 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -92,23 +92,25 @@ const httplog = Output.scoped(.Server, false);
 const ctxLog = Output.scoped(.RequestContext, false);
 const BlobFileContentResult = struct {
     data: [:0]const u8,
-    fn init(comptime fieldname: []const u8, js_obj: JSC.JSValue, global: *JSC.JSGlobalObject, exception: JSC.C.ExceptionRef) ?BlobFileContentResult {
-        if (JSC.WebCore.Body.Value.fromJS(global, js_obj)) |body| {
+
+    fn init(comptime fieldname: []const u8, js_obj: JSC.JSValue, global: *JSC.JSGlobalObject) bun.JSError!?BlobFileContentResult {
+        {
+            const body = try JSC.WebCore.Body.Value.fromJS(global, js_obj);
             if (body == .Blob and body.Blob.store != null and body.Blob.store.?.data == .file) {
                 var fs: JSC.Node.NodeFS = .{};
                 const read = fs.readFileWithOptions(.{ .path = body.Blob.store.?.data.file.pathlike }, .sync, .null_terminated);
                 switch (read) {
                     .err => {
                         global.throwValue(read.err.toJSC(global));
-                        return .{ .data = "" };
+                        return error.JSError;
                     },
                     else => {
                         const str = read.result.null_terminated;
                         if (str.len > 0) {
                             return .{ .data = str };
                         }
-                        JSC.throwInvalidArguments(std.fmt.comptimePrint("Invalid {s} file", .{fieldname}), .{}, global, exception);
-                        return .{ .data = str };
+                        global.throwInvalidArguments(std.fmt.comptimePrint("Invalid {s} file", .{fieldname}), .{});
+                        return error.JSError;
                     },
                 }
             }
@@ -198,7 +200,7 @@ const StaticRoute = struct {
         this.destroy();
     }
 
-    pub fn fromJS(globalThis: *JSC.JSGlobalObject, argument: JSC.JSValue) ?*Route {
+    pub fn fromJS(globalThis: *JSC.JSGlobalObject, argument: JSC.JSValue) bun.JSError!*Route {
         if (argument.as(JSC.WebCore.Response)) |response| {
 
             // The user may want to pass in the same Response object multiple endpoints
@@ -208,13 +210,11 @@ const StaticRoute = struct {
             var blob: AnyBlob = brk: {
                 switch (response.body.value) {
                     .Used => {
-                        globalThis.throwInvalidArguments("Response body has already been used", .{});
-                        return null;
+                        return globalThis.throwInvalidArguments2("Response body has already been used", .{});
                     },
 
                     else => {
-                        globalThis.throwInvalidArguments("Body must be fully buffered before it can be used in a static route. Consider calling new Response(await response.blob()) to buffer the body.", .{});
-                        return null;
+                        return globalThis.throwInvalidArguments2("Body must be fully buffered before it can be used in a static route. Consider calling new Response(await response.blob()) to buffer the body.", .{});
                     },
                     .Null, .Empty => {
                         break :brk AnyBlob{
@@ -227,7 +227,7 @@ const StaticRoute = struct {
                     .Blob, .InternalBlob, .WTFStringImpl => {
                         if (response.body.value == .Blob and response.body.value.Blob.needsToReadFile()) {
                             globalThis.throwTODO("TODO: support Bun.file(path) in static routes");
-                            return null;
+                            return error.JSError;
                         }
                         var blob = response.body.value.use();
                         blob.globalThis = globalThis;
@@ -253,7 +253,7 @@ const StaticRoute = struct {
                 }) catch {
                     blob.detach();
                     globalThis.throwOutOfMemory();
-                    return null;
+                    return error.JSError;
                 }
             else
                 .{
@@ -270,8 +270,7 @@ const StaticRoute = struct {
             });
         }
 
-        globalThis.throwInvalidArguments("Expected a Response object", .{});
-        return null;
+        return globalThis.throwInvalidArguments2("Expected a Response object", .{});
     }
 
     // HEAD requests have no body.
@@ -465,6 +464,8 @@ pub const ServerConfig = struct {
 
     static_routes: std.ArrayList(StaticRouteEntry) = std.ArrayList(StaticRouteEntry).init(bun.default_allocator),
 
+    bake: ?bun.bake.UserOptions = null,
+
     pub const StaticRouteEntry = struct {
         path: []const u8,
         route: *StaticRoute,
@@ -521,6 +522,10 @@ pub const ServerConfig = struct {
             entry.deinit();
         }
         this.static_routes.clearAndFree();
+
+        if (this.bake) |*bake| {
+            bake.deinit();
+        }
     }
 
     pub fn computeID(this: *const ServerConfig, allocator: std.mem.Allocator) []const u8 {
@@ -747,15 +752,15 @@ pub const ServerConfig = struct {
 
         pub const zero = SSLConfig{};
 
-        pub fn inJS(vm: *JSC.VirtualMachine, global: *JSC.JSGlobalObject, obj: JSC.JSValue, exception: JSC.C.ExceptionRef) ?SSLConfig {
+        pub fn fromJS(vm: *JSC.VirtualMachine, global: *JSC.JSGlobalObject, obj: JSC.JSValue) bun.JSError!?SSLConfig {
             var result = zero;
+            errdefer result.deinit();
 
             var arena: bun.ArenaAllocator = bun.ArenaAllocator.init(bun.default_allocator);
             defer arena.deinit();
 
             if (!obj.isObject()) {
-                JSC.throwInvalidArguments("tls option expects an object", .{}, global, exception);
-                return null;
+                return global.throwInvalidArguments2("tls option expects an object", .{});
             }
 
             var any = false;
@@ -763,23 +768,20 @@ pub const ServerConfig = struct {
             result.reject_unauthorized = @intFromBool(vm.getTLSRejectUnauthorized());
 
             // Required
-            if (obj.getTruthy(global, "keyFile")) |key_file_name| {
+            if (try obj.getTruthy(global, "keyFile")) |key_file_name| {
                 var sliced = key_file_name.toSlice(global, bun.default_allocator);
                 defer sliced.deinit();
                 if (sliced.len > 0) {
                     result.key_file_name = bun.default_allocator.dupeZ(u8, sliced.slice()) catch unreachable;
                     if (std.posix.system.access(result.key_file_name, std.posix.F_OK) != 0) {
-                        JSC.throwInvalidArguments("Unable to access keyFile path", .{}, global, exception);
-                        result.deinit();
-
-                        return null;
+                        return global.throwInvalidArguments2("Unable to access keyFile path", .{});
                     }
                     any = true;
                     result.requires_custom_request_ctx = true;
                 }
             }
 
-            if (obj.getTruthy(global, "key")) |js_obj| {
+            if (try obj.getTruthy(global, "key")) |js_obj| {
                 if (js_obj.jsType().isArray()) {
                     const count = js_obj.getLength(global);
                     if (count > 0) {
@@ -797,7 +799,7 @@ pub const ServerConfig = struct {
                                     any = true;
                                     result.requires_custom_request_ctx = true;
                                 }
-                            } else if (BlobFileContentResult.init("key", item, global, exception)) |content| {
+                            } else if (try BlobFileContentResult.init("key", item, global)) |content| {
                                 if (content.data.len > 0) {
                                     native_array[valid_count] = content.data.ptr;
                                     valid_count += 1;
@@ -813,8 +815,7 @@ pub const ServerConfig = struct {
                                 global.throwInvalidArguments("key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                                 // mark and free all keys
                                 result.key = native_array;
-                                result.deinit();
-                                return null;
+                                return error.JSError;
                             }
                         }
 
@@ -826,7 +827,7 @@ pub const ServerConfig = struct {
 
                         result.key_count = valid_count;
                     }
-                } else if (BlobFileContentResult.init("key", js_obj, global, exception)) |content| {
+                } else if (try BlobFileContentResult.init("key", js_obj, global)) |content| {
                     if (content.data.len > 0) {
                         const native_array = bun.default_allocator.alloc([*c]const u8, 1) catch unreachable;
                         native_array[0] = content.data.ptr;
@@ -856,28 +857,25 @@ pub const ServerConfig = struct {
                         global.throwInvalidArguments("key argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                         // mark and free all certs
                         result.key = native_array;
-                        result.deinit();
-                        return null;
+                        return error.JSError;
                     }
                 }
             }
 
-            if (obj.getTruthy(global, "certFile")) |cert_file_name| {
+            if (try obj.getTruthy(global, "certFile")) |cert_file_name| {
                 var sliced = cert_file_name.toSlice(global, bun.default_allocator);
                 defer sliced.deinit();
                 if (sliced.len > 0) {
                     result.cert_file_name = bun.default_allocator.dupeZ(u8, sliced.slice()) catch unreachable;
                     if (std.posix.system.access(result.cert_file_name, std.posix.F_OK) != 0) {
-                        JSC.throwInvalidArguments("Unable to access certFile path", .{}, global, exception);
-                        result.deinit();
-                        return null;
+                        return global.throwInvalidArguments2("Unable to access certFile path", .{});
                     }
                     any = true;
                     result.requires_custom_request_ctx = true;
                 }
             }
 
-            if (obj.getTruthy(global, "ALPNProtocols")) |protocols| {
+            if (try obj.getTruthy(global, "ALPNProtocols")) |protocols| {
                 if (JSC.Node.StringOrBuffer.fromJS(global, arena.allocator(), protocols)) |sb| {
                     defer sb.deinit();
                     const sliced = sb.slice();
@@ -889,13 +887,11 @@ pub const ServerConfig = struct {
                     any = true;
                     result.requires_custom_request_ctx = true;
                 } else {
-                    global.throwInvalidArguments("ALPNProtocols argument must be an string, Buffer or TypedArray", .{});
-                    result.deinit();
-                    return null;
+                    return global.throwInvalidArguments2("ALPNProtocols argument must be an string, Buffer or TypedArray", .{});
                 }
             }
 
-            if (obj.getTruthy(global, "cert")) |js_obj| {
+            if (try obj.getTruthy(global, "cert")) |js_obj| {
                 if (js_obj.jsType().isArray()) {
                     const count = js_obj.getLength(global);
                     if (count > 0) {
@@ -913,7 +909,7 @@ pub const ServerConfig = struct {
                                     any = true;
                                     result.requires_custom_request_ctx = true;
                                 }
-                            } else if (BlobFileContentResult.init("cert", item, global, exception)) |content| {
+                            } else if (try BlobFileContentResult.init("cert", item, global)) |content| {
                                 if (content.data.len > 0) {
                                     native_array[valid_count] = content.data.ptr;
                                     valid_count += 1;
@@ -929,8 +925,7 @@ pub const ServerConfig = struct {
                                 global.throwInvalidArguments("cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                                 // mark and free all certs
                                 result.cert = native_array;
-                                result.deinit();
-                                return null;
+                                return error.JSError;
                             }
                         }
 
@@ -942,7 +937,7 @@ pub const ServerConfig = struct {
 
                         result.cert_count = valid_count;
                     }
-                } else if (BlobFileContentResult.init("cert", js_obj, global, exception)) |content| {
+                } else if (try BlobFileContentResult.init("cert", js_obj, global)) |content| {
                     if (content.data.len > 0) {
                         const native_array = bun.default_allocator.alloc([*c]const u8, 1) catch unreachable;
                         native_array[0] = content.data.ptr;
@@ -972,35 +967,30 @@ pub const ServerConfig = struct {
                         global.throwInvalidArguments("cert argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                         // mark and free all certs
                         result.cert = native_array;
-                        result.deinit();
-                        return null;
+                        return error.JSError;
                     }
                 }
             }
 
-            if (obj.getTruthy(global, "requestCert")) |request_cert| {
+            if (try obj.getTruthy(global, "requestCert")) |request_cert| {
                 if (request_cert.isBoolean()) {
                     result.request_cert = if (request_cert.asBoolean()) 1 else 0;
                     any = true;
                 } else {
-                    global.throw("Expected requestCert to be a boolean", .{});
-                    result.deinit();
-                    return null;
+                    return global.throw2("Expected requestCert to be a boolean", .{});
                 }
             }
 
-            if (obj.getTruthy(global, "rejectUnauthorized")) |reject_unauthorized| {
+            if (try obj.getTruthy(global, "rejectUnauthorized")) |reject_unauthorized| {
                 if (reject_unauthorized.isBoolean()) {
                     result.reject_unauthorized = if (reject_unauthorized.asBoolean()) 1 else 0;
                     any = true;
                 } else {
-                    global.throw("Expected rejectUnauthorized to be a boolean", .{});
-                    result.deinit();
-                    return null;
+                    return global.throw2("Expected rejectUnauthorized to be a boolean", .{});
                 }
             }
 
-            if (obj.getTruthy(global, "ciphers")) |ssl_ciphers| {
+            if (try obj.getTruthy(global, "ciphers")) |ssl_ciphers| {
                 var sliced = ssl_ciphers.toSlice(global, bun.default_allocator);
                 defer sliced.deinit();
                 if (sliced.len > 0) {
@@ -1010,7 +1000,7 @@ pub const ServerConfig = struct {
                 }
             }
 
-            if (obj.getTruthy(global, "serverName") orelse obj.getTruthy(global, "servername")) |server_name| {
+            if (try obj.getTruthy(global, "serverName") orelse try obj.getTruthy(global, "servername")) |server_name| {
                 var sliced = server_name.toSlice(global, bun.default_allocator);
                 defer sliced.deinit();
                 if (sliced.len > 0) {
@@ -1020,7 +1010,7 @@ pub const ServerConfig = struct {
                 }
             }
 
-            if (obj.getTruthy(global, "ca")) |js_obj| {
+            if (try obj.getTruthy(global, "ca")) |js_obj| {
                 if (js_obj.jsType().isArray()) {
                     const count = js_obj.getLength(global);
                     if (count > 0) {
@@ -1038,7 +1028,7 @@ pub const ServerConfig = struct {
                                     any = true;
                                     result.requires_custom_request_ctx = true;
                                 }
-                            } else if (BlobFileContentResult.init("ca", item, global, exception)) |content| {
+                            } else if (try BlobFileContentResult.init("ca", item, global)) |content| {
                                 if (content.data.len > 0) {
                                     native_array[valid_count] = content.data.ptr;
                                     valid_count += 1;
@@ -1054,8 +1044,7 @@ pub const ServerConfig = struct {
                                 global.throwInvalidArguments("ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                                 // mark and free all CA's
                                 result.cert = native_array;
-                                result.deinit();
-                                return null;
+                                return error.JSError;
                             }
                         }
 
@@ -1067,7 +1056,7 @@ pub const ServerConfig = struct {
 
                         result.ca_count = valid_count;
                     }
-                } else if (BlobFileContentResult.init("ca", js_obj, global, exception)) |content| {
+                } else if (try BlobFileContentResult.init("ca", js_obj, global)) |content| {
                     if (content.data.len > 0) {
                         const native_array = bun.default_allocator.alloc([*c]const u8, 1) catch unreachable;
                         native_array[0] = content.data.ptr;
@@ -1094,61 +1083,56 @@ pub const ServerConfig = struct {
                             bun.default_allocator.free(native_array);
                         }
                     } else {
-                        JSC.throwInvalidArguments("ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{}, global, exception);
+                        global.throwInvalidArguments("ca argument must be an string, Buffer, TypedArray, BunFile or an array containing string, Buffer, TypedArray or BunFile", .{});
                         // mark and free all certs
                         result.ca = native_array;
-                        result.deinit();
-                        return null;
+                        return error.JSError;
                     }
                 }
             }
 
-            if (obj.getTruthy(global, "caFile")) |ca_file_name| {
+            if (try obj.getTruthy(global, "caFile")) |ca_file_name| {
                 var sliced = ca_file_name.toSlice(global, bun.default_allocator);
                 defer sliced.deinit();
                 if (sliced.len > 0) {
                     result.ca_file_name = bun.default_allocator.dupeZ(u8, sliced.slice()) catch unreachable;
                     if (std.posix.system.access(result.ca_file_name, std.posix.F_OK) != 0) {
-                        JSC.throwInvalidArguments("Invalid caFile path", .{}, global, exception);
-                        result.deinit();
-                        return null;
+                        return global.throwInvalidArguments2("Invalid caFile path", .{});
                     }
                 }
             }
             // Optional
             if (any) {
-                if (obj.getTruthy(global, "secureOptions")) |secure_options| {
+                if (try obj.getTruthy(global, "secureOptions")) |secure_options| {
                     if (secure_options.isNumber()) {
                         result.secure_options = secure_options.toU32();
                     }
                 }
 
-                if (obj.getTruthy(global, "clientRenegotiationLimit")) |client_renegotiation_limit| {
+                if (try obj.getTruthy(global, "clientRenegotiationLimit")) |client_renegotiation_limit| {
                     if (client_renegotiation_limit.isNumber()) {
                         result.client_renegotiation_limit = client_renegotiation_limit.toU32();
                     }
                 }
 
-                if (obj.getTruthy(global, "clientRenegotiationWindow")) |client_renegotiation_window| {
+                if (try obj.getTruthy(global, "clientRenegotiationWindow")) |client_renegotiation_window| {
                     if (client_renegotiation_window.isNumber()) {
                         result.client_renegotiation_window = client_renegotiation_window.toU32();
                     }
                 }
 
-                if (obj.getTruthy(global, "dhParamsFile")) |dh_params_file_name| {
+                if (try obj.getTruthy(global, "dhParamsFile")) |dh_params_file_name| {
                     var sliced = dh_params_file_name.toSlice(global, bun.default_allocator);
                     defer sliced.deinit();
                     if (sliced.len > 0) {
                         result.dh_params_file_name = bun.default_allocator.dupeZ(u8, sliced.slice()) catch unreachable;
                         if (std.posix.system.access(result.dh_params_file_name, std.posix.F_OK) != 0) {
-                            JSC.throwInvalidArguments("Invalid dhParamsFile path", .{}, global, exception);
-                            result.deinit();
-                            return null;
+                            return global.throwInvalidArguments2("Invalid dhParamsFile path", .{});
                         }
                     }
                 }
 
-                if (obj.getTruthy(global, "passphrase")) |passphrase| {
+                if (try obj.getTruthy(global, "passphrase")) |passphrase| {
                     var sliced = passphrase.toSlice(global, bun.default_allocator);
                     defer sliced.deinit();
                     if (sliced.len > 0) {
@@ -1161,9 +1145,7 @@ pub const ServerConfig = struct {
                         result.low_memory_mode = low_memory_mode.toBoolean();
                         any = true;
                     } else {
-                        global.throw("Expected lowMemoryMode to be a boolean", .{});
-                        result.deinit();
-                        return null;
+                        return global.throw2("Expected lowMemoryMode to be a boolean", .{});
                     }
                 }
             }
@@ -1178,8 +1160,8 @@ pub const ServerConfig = struct {
         global: *JSC.JSGlobalObject,
         args: *ServerConfig,
         arguments: *JSC.Node.ArgumentsSlice,
-        exception: JSC.C.ExceptionRef,
-    ) void {
+        allow_bake_config: bool,
+    ) bun.JSError!void {
         const vm = arguments.vm;
         const env = vm.bundler.env;
 
@@ -1230,7 +1212,7 @@ pub const ServerConfig = struct {
         }
 
         defer {
-            if (global.hasException() or exception.* != null) {
+            if (global.hasException()) {
                 if (args.ssl_config) |*conf| {
                     conf.deinit();
                     args.ssl_config = null;
@@ -1240,14 +1222,12 @@ pub const ServerConfig = struct {
 
         if (arguments.next()) |arg| {
             if (!arg.isObject()) {
-                JSC.throwInvalidArguments("Bun.serve expects an object", .{}, global, exception);
-                return;
+                return global.throwInvalidArguments2("Bun.serve expects an object", .{});
             }
 
             if (arg.get(global, "static")) |static| {
                 if (!static.isObject()) {
-                    JSC.throwInvalidArguments("Bun.serve expects 'static' to be an object shaped like { [pathname: string]: Response }", .{}, global, exception);
-                    return;
+                    return global.throwInvalidArguments2("Bun.serve expects 'static' to be an object shaped like { [pathname: string]: Response }", .{});
                 }
 
                 var iter = JSC.JSPropertyIterator(.{
@@ -1263,72 +1243,57 @@ pub const ServerConfig = struct {
 
                     if (path.len == 0 or path[0] != '/') {
                         bun.default_allocator.free(path);
-                        JSC.throwInvalidArguments("Invalid static route \"{s}\". path must start with '/'", .{path}, global, exception);
-                        return;
+                        return global.throwInvalidArguments2("Invalid static route \"{s}\". path must start with '/'", .{path});
                     }
 
                     if (!is_ascii) {
                         bun.default_allocator.free(path);
-                        JSC.throwInvalidArguments("Invalid static route \"{s}\". Please encode all non-ASCII characters in the path.", .{path}, global, exception);
-                        return;
+                        return global.throwInvalidArguments2("Invalid static route \"{s}\". Please encode all non-ASCII characters in the path.", .{path});
                     }
 
-                    if (StaticRoute.fromJS(global, value)) |route| {
-                        args.static_routes.append(.{
-                            .path = path,
-                            .route = route,
-                        }) catch bun.outOfMemory();
-                    } else if (global.hasException()) {
-                        bun.default_allocator.free(path);
-                        return;
-                    } else {
-                        Output.panic("Internal error: expected exception or static route", .{});
-                    }
+                    const route = try StaticRoute.fromJS(global, value);
+                    args.static_routes.append(.{
+                        .path = path,
+                        .route = route,
+                    }) catch bun.outOfMemory();
                 }
             }
 
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
             if (arg.get(global, "idleTimeout")) |value| {
                 if (!value.isUndefinedOrNull()) {
                     if (!value.isAnyInt()) {
-                        JSC.throwInvalidArguments("Bun.serve expects idleTimeout to be an integer", .{}, global, exception);
-
-                        return;
+                        global.throwInvalidArguments("Bun.serve expects idleTimeout to be an integer", .{});
+                        return error.JSError;
                     }
                     args.has_idleTimeout = true;
 
                     const idleTimeout: u64 = @intCast(@max(value.toInt64(), 0));
                     if (idleTimeout > 255) {
-                        JSC.throwInvalidArguments("Bun.serve expects idleTimeout to be 255 or less", .{}, global, exception);
-                        return;
+                        global.throwInvalidArguments("Bun.serve expects idleTimeout to be 255 or less", .{});
+                        return error.JSError;
                     }
 
                     args.idleTimeout = @truncate(idleTimeout);
                 }
             }
 
-            if (arg.getTruthy(global, "webSocket") orelse arg.getTruthy(global, "websocket")) |websocket_object| {
+            if (try arg.getTruthy(global, "webSocket") orelse try arg.getTruthy(global, "websocket")) |websocket_object| {
                 if (!websocket_object.isObject()) {
-                    JSC.throwInvalidArguments("Expected websocket to be an object", .{}, global, exception);
+                    global.throwInvalidArguments("Expected websocket to be an object", .{});
                     if (args.ssl_config) |*conf| {
                         conf.deinit();
                     }
-                    return;
+                    return error.JSError;
                 }
 
-                if (WebSocketServer.onCreate(global, websocket_object)) |wss| {
-                    args.websocket = wss;
-                } else {
-                    if (args.ssl_config) |*conf| {
-                        conf.deinit();
-                    }
-                    return;
-                }
+                errdefer if (args.ssl_config) |*conf| conf.deinit();
+                args.websocket = try WebSocketServer.onCreate(global, websocket_object);
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthy(global, "port")) |port_| {
+            if (try arg.getTruthy(global, "port")) |port_| {
                 args.address.tcp.port = @as(
                     u16,
                     @intCast(@min(
@@ -1338,9 +1303,9 @@ pub const ServerConfig = struct {
                 );
                 port = args.address.tcp.port;
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthy(global, "baseURI")) |baseURI| {
+            if (try arg.getTruthy(global, "baseURI")) |baseURI| {
                 var sliced = baseURI.toSlice(global, bun.default_allocator);
 
                 if (sliced.len > 0) {
@@ -1348,9 +1313,9 @@ pub const ServerConfig = struct {
                     args.base_uri = bun.default_allocator.dupe(u8, sliced.slice()) catch unreachable;
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthy(global, "hostname") orelse arg.getTruthy(global, "host")) |host| {
+            if (try arg.getTruthy(global, "hostname") orelse try arg.getTruthy(global, "host")) |host| {
                 const host_str = host.toSlice(
                     global,
                     bun.default_allocator,
@@ -1362,9 +1327,9 @@ pub const ServerConfig = struct {
                     has_hostname = true;
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthy(global, "unix")) |unix| {
+            if (try arg.getTruthy(global, "unix")) |unix| {
                 const unix_str = unix.toSlice(
                     global,
                     bun.default_allocator,
@@ -1372,14 +1337,14 @@ pub const ServerConfig = struct {
                 defer unix_str.deinit();
                 if (unix_str.len > 0) {
                     if (has_hostname) {
-                        JSC.throwInvalidArguments("Cannot specify both hostname and unix", .{}, global, exception);
-                        return;
+                        global.throwInvalidArguments("Cannot specify both hostname and unix", .{});
+                        return error.JSError;
                     }
 
                     args.address = .{ .unix = bun.default_allocator.dupeZ(u8, unix_str.slice()) catch unreachable };
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
             if (arg.get(global, "id")) |id| {
                 if (id.isUndefinedOrNull()) {
@@ -1397,78 +1362,90 @@ pub const ServerConfig = struct {
                     }
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
             if (arg.get(global, "development")) |dev| {
                 args.development = dev.coerce(bool, global);
                 args.reuse_port = !args.development;
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
+
+            if (try arg.getTruthy(global, "app")) |bake_args_js| {
+                if (!bun.FeatureFlags.bake) {
+                    return global.throwInvalidArguments2("To use the experimental \"app\" option, upgrade to the canary build of bun via \"bun upgrade --canary\"", .{});
+                }
+                if (!allow_bake_config) {
+                    return global.throwInvalidArguments2("To use the \"app\" option, change from calling \"Bun.serve({ app })\" to \"export default { app: ... }\"", .{});
+                }
+                if (!args.development) {
+                    return global.throwInvalidArguments2("TODO: 'development: false' in serve options with 'app'. For now, use `bun build --app` or set 'development: true'", .{});
+                }
+
+                args.bake = try bun.bake.UserOptions.fromJS(bake_args_js, global);
+            }
 
             if (arg.get(global, "reusePort")) |dev| {
                 args.reuse_port = dev.coerce(bool, global);
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
             if (arg.get(global, "inspector")) |inspector| {
                 args.inspector = inspector.coerce(bool, global);
 
                 if (args.inspector and !args.development) {
-                    JSC.throwInvalidArguments("Cannot enable inspector in production. Please set development: true in Bun.serve()", .{}, global, exception);
-                    return;
+                    global.throwInvalidArguments("Cannot enable inspector in production. Please set development: true in Bun.serve()", .{});
+                    return error.JSError;
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthy(global, "maxRequestBodySize")) |max_request_body_size| {
+            if (try arg.getTruthy(global, "maxRequestBodySize")) |max_request_body_size| {
                 if (max_request_body_size.isNumber()) {
                     args.max_request_body_size = @as(u64, @intCast(@max(0, max_request_body_size.toInt64())));
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthyComptime(global, "error")) |onError| {
+            if (try arg.getTruthyComptime(global, "error")) |onError| {
                 if (!onError.isCallable(global.vm())) {
-                    JSC.throwInvalidArguments("Expected error to be a function", .{}, global, exception);
-                    return;
+                    global.throwInvalidArguments("Expected error to be a function", .{});
+                    return error.JSError;
                 }
                 const onErrorSnapshot = onError.withAsyncContextIfNeeded(global);
                 args.onError = onErrorSnapshot;
                 onErrorSnapshot.protect();
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
-            if (arg.getTruthy(global, "fetch")) |onRequest_| {
+            if (try arg.getTruthy(global, "fetch")) |onRequest_| {
                 if (!onRequest_.isCallable(global.vm())) {
-                    JSC.throwInvalidArguments("Expected fetch() to be a function", .{}, global, exception);
-                    return;
+                    global.throwInvalidArguments("Expected fetch() to be a function", .{});
+                    return error.JSError;
                 }
                 const onRequest = onRequest_.withAsyncContextIfNeeded(global);
                 JSC.C.JSValueProtect(global, onRequest.asObjectRef());
                 args.onRequest = onRequest;
+            } else if (args.bake == null) {
+                if (global.hasException()) return error.JSError;
+                global.throwInvalidArguments("Expected fetch() to be a function", .{});
+                return error.JSError;
             } else {
-                if (global.hasException()) return;
-                JSC.throwInvalidArguments("Expected fetch() to be a function", .{}, global, exception);
-                return;
+                if (global.hasException()) return error.JSError;
             }
 
-            if (arg.getTruthy(global, "tls")) |tls| {
+            if (try arg.getTruthy(global, "tls")) |tls| {
                 if (tls.isFalsey()) {
                     args.ssl_config = null;
                 } else if (tls.jsType().isArray()) {
                     var value_iter = tls.arrayIterator(global);
                     if (value_iter.len == 1) {
-                        JSC.throwInvalidArguments("tls option expects at least 1 tls object", .{}, global, exception);
-                        return;
+                        global.throwInvalidArguments("tls option expects at least 1 tls object", .{});
+                        return error.JSError;
                     }
                     while (value_iter.next()) |item| {
-                        var ssl_config = SSLConfig.inJS(vm, global, item, exception) orelse {
-                            if (exception.* != null) {
-                                return;
-                            }
-
+                        var ssl_config = try SSLConfig.fromJS(vm, global, item) orelse {
                             if (global.hasException()) {
-                                return;
+                                return error.JSError;
                             }
 
                             // Backwards-compatibility; we ignored empty tls objects.
@@ -1480,8 +1457,8 @@ pub const ServerConfig = struct {
                         } else {
                             if (ssl_config.server_name == null or std.mem.span(ssl_config.server_name).len == 0) {
                                 defer ssl_config.deinit();
-                                JSC.throwInvalidArguments("SNI tls object must have a serverName", .{}, global, exception);
-                                return;
+                                global.throwInvalidArguments("SNI tls object must have a serverName", .{});
+                                return error.JSError;
                             }
                             if (args.sni == null) {
                                 args.sni = bun.BabyList(SSLConfig).initCapacity(bun.default_allocator, value_iter.len - 1) catch bun.outOfMemory();
@@ -1491,55 +1468,45 @@ pub const ServerConfig = struct {
                         }
                     }
                 } else {
-                    if (SSLConfig.inJS(vm, global, tls, exception)) |ssl_config| {
+                    if (try SSLConfig.fromJS(vm, global, tls)) |ssl_config| {
                         args.ssl_config = ssl_config;
                     }
-
-                    if (exception.* != null) {
-                        return;
-                    }
-
                     if (global.hasException()) {
-                        return;
+                        return error.JSError;
                     }
                 }
             }
-            if (global.hasException()) return;
+            if (global.hasException()) return error.JSError;
 
             // @compatibility Bun v0.x - v0.2.1
             // this used to be top-level, now it's "tls" object
             if (args.ssl_config == null) {
-                if (SSLConfig.inJS(vm, global, arg, exception)) |ssl_config| {
+                if (try SSLConfig.fromJS(vm, global, arg)) |ssl_config| {
                     args.ssl_config = ssl_config;
                 }
-
-                if (exception.* != null) {
-                    return;
-                }
-
                 if (global.hasException()) {
-                    return;
+                    return error.JSError;
                 }
             }
         } else {
-            JSC.throwInvalidArguments("Bun.serve expects an object", .{}, global, exception);
-            return;
+            global.throwInvalidArguments("Bun.serve expects an object", .{});
+            return error.JSError;
         }
 
         if (args.base_uri.len > 0) {
             args.base_url = URL.parse(args.base_uri);
             if (args.base_url.hostname.len == 0) {
-                JSC.throwInvalidArguments("baseURI must have a hostname", .{}, global, exception);
+                global.throwInvalidArguments("baseURI must have a hostname", .{});
                 bun.default_allocator.free(@constCast(args.base_uri));
                 args.base_uri = "";
-                return;
+                return error.JSError;
             }
 
             if (!strings.isAllASCII(args.base_uri)) {
-                JSC.throwInvalidArguments("Unicode baseURI must already be encoded for now.\nnew URL(baseuRI).toString() should do the trick.", .{}, global, exception);
+                global.throwInvalidArguments("Unicode baseURI must already be encoded for now.\nnew URL(baseuRI).toString() should do the trick.", .{});
                 bun.default_allocator.free(@constCast(args.base_uri));
                 args.base_uri = "";
-                return;
+                return error.JSError;
             }
 
             if (args.base_url.protocol.len == 0) {
@@ -1604,10 +1571,10 @@ pub const ServerConfig = struct {
             }
 
             if (!strings.isAllASCII(hostname)) {
-                JSC.throwInvalidArguments("Unicode hostnames must already be encoded for now.\nnew URL(input).hostname should do the trick.", .{}, global, exception);
+                global.throwInvalidArguments("Unicode hostnames must already be encoded for now.\nnew URL(input).hostname should do the trick.", .{});
                 bun.default_allocator.free(@constCast(args.base_uri));
                 args.base_uri = "";
-                return;
+                return error.JSError;
             }
 
             args.base_url = URL.parse(args.base_uri);
@@ -1616,17 +1583,17 @@ pub const ServerConfig = struct {
         // I don't think there's a case where this can happen
         // but let's check anyway, just in case
         if (args.base_url.hostname.len == 0) {
-            JSC.throwInvalidArguments("baseURI must have a hostname", .{}, global, exception);
+            global.throwInvalidArguments("baseURI must have a hostname", .{});
             bun.default_allocator.free(@constCast(args.base_uri));
             args.base_uri = "";
-            return;
+            return error.JSError;
         }
 
         if (args.base_url.username.len > 0 or args.base_url.password.len > 0) {
-            JSC.throwInvalidArguments("baseURI can't have a username or password", .{}, global, exception);
+            global.throwInvalidArguments("baseURI can't have a username or password", .{});
             bun.default_allocator.free(@constCast(args.base_uri));
             args.base_uri = "";
-            return;
+            return error.JSError;
         }
 
         return;
@@ -1974,7 +1941,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             }
         }
 
-        pub fn onResolve(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn onResolve(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             ctxLog("onResolve", .{});
 
             const arguments = callframe.arguments(2);
@@ -2000,7 +1967,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
 
                 if (class_name.eqlComptime("Response")) {
                     Output.errGeneric("Expected a native Response object, but received a polyfilled Response object. Bun.serve() only supports native Response objects.", .{});
-                } else if (!value.isEmpty() and !globalThis.hasException()) {
+                } else if (value != .zero and !globalThis.hasException()) {
                     var formatter = JSC.ConsoleObject.Formatter{
                         .globalThis = globalThis,
                         .quote_strings = true,
@@ -2119,7 +2086,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             this.ref_count += 1;
         }
 
-        pub fn onReject(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn onReject(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             ctxLog("onReject", .{});
 
             const arguments = callframe.arguments(2);
@@ -2500,7 +2467,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
                 this.flags.has_finalized = true;
             }
 
-            if (!this.response_jsvalue.isEmpty()) {
+            if (this.response_jsvalue != .zero) {
                 ctxLog("finalizeWithoutDeinit: response_jsvalue != .zero", .{});
                 if (this.flags.response_protected) {
                     this.response_jsvalue.unprotect();
@@ -3188,13 +3155,9 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         pub fn onResponse(
             ctx: *RequestContext,
             this: *ThisServer,
-            req: *uws.Request,
-            request_object: *Request,
             request_value: JSValue,
             response_value: JSValue,
         ) void {
-            _ = request_object;
-            _ = req;
             request_value.ensureStillAlive();
             response_value.ensureStillAlive();
             ctx.drainMicrotasks();
@@ -3341,7 +3304,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             req.endStream(req.shouldCloseConnection());
         }
 
-        pub fn onResolveStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn onResolveStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             streamLog("onResolveStream", .{});
             var args = callframe.arguments(2);
             var req: *@This() = args.ptr[args.len - 1].asPromisePtr(@This());
@@ -3349,7 +3312,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
             req.handleResolveStream();
             return JSValue.jsUndefined();
         }
-        pub fn onRejectStream(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn onRejectStream(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             streamLog("onRejectStream", .{});
             const args = callframe.arguments(2);
             var req = args.ptr[args.len - 1].asPromisePtr(@This());
@@ -3698,7 +3661,7 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         ) void {
             JSC.markBinding(@src());
             if (this.server) |server| {
-                if (!server.config.onError.isEmpty() and !this.flags.has_called_error_handler) {
+                if (server.config.onError != .zero and !this.flags.has_called_error_handler) {
                     this.flags.has_called_error_handler = true;
                     const result = server.config.onError.call(
                         server.globalThis,
@@ -4132,18 +4095,14 @@ fn NewRequestContext(comptime ssl_enabled: bool, comptime debug_mode: bool, comp
         });
 
         comptime {
-            @export(onResolve, .{
-                .name = Export[0].symbol_name,
-            });
-            @export(onReject, .{
-                .name = Export[1].symbol_name,
-            });
-            @export(onResolveStream, .{
-                .name = Export[2].symbol_name,
-            });
-            @export(onRejectStream, .{
-                .name = Export[3].symbol_name,
-            });
+            const jsonResolve = JSC.toJSHostFunction(onResolve);
+            @export(jsonResolve, .{ .name = Export[0].symbol_name });
+            const jsonReject = JSC.toJSHostFunction(onReject);
+            @export(jsonReject, .{ .name = Export[1].symbol_name });
+            const jsonResolveStream = JSC.toJSHostFunction(onResolveStream);
+            @export(jsonResolveStream, .{ .name = Export[2].symbol_name });
+            const jsonRejectStream = JSC.toJSHostFunction(onRejectStream);
+            @export(jsonRejectStream, .{ .name = Export[3].symbol_name });
         }
     };
 }
@@ -4194,16 +4153,15 @@ pub const WebSocketServer = struct {
             _ = vm.uncaughtException(globalObject, error_value, false);
         }
 
-        pub fn fromJS(globalObject: *JSC.JSGlobalObject, object: JSC.JSValue) ?Handler {
+        pub fn fromJS(globalObject: *JSC.JSGlobalObject, object: JSC.JSValue) bun.JSError!Handler {
             const vm = globalObject.vm();
             var handler = Handler{ .globalObject = globalObject, .vm = VirtualMachine.get() };
 
             var valid = false;
 
-            if (object.getTruthyComptime(globalObject, "message")) |message_| {
+            if (try object.getTruthyComptime(globalObject, "message")) |message_| {
                 if (!message_.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the message option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the message option", .{});
                 }
                 const message = message_.withAsyncContextIfNeeded(globalObject);
                 handler.onMessage = message;
@@ -4211,10 +4169,9 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getTruthy(globalObject, "open")) |open_| {
+            if (try object.getTruthy(globalObject, "open")) |open_| {
                 if (!open_.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the open option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the open option", .{});
                 }
                 const open = open_.withAsyncContextIfNeeded(globalObject);
                 handler.onOpen = open;
@@ -4222,10 +4179,9 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getTruthy(globalObject, "close")) |close_| {
+            if (try object.getTruthy(globalObject, "close")) |close_| {
                 if (!close_.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the close option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the close option", .{});
                 }
                 const close = close_.withAsyncContextIfNeeded(globalObject);
                 handler.onClose = close;
@@ -4233,10 +4189,9 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getTruthy(globalObject, "drain")) |drain_| {
+            if (try object.getTruthy(globalObject, "drain")) |drain_| {
                 if (!drain_.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the drain option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the drain option", .{});
                 }
                 const drain = drain_.withAsyncContextIfNeeded(globalObject);
                 handler.onDrain = drain;
@@ -4244,30 +4199,27 @@ pub const WebSocketServer = struct {
                 valid = true;
             }
 
-            if (object.getTruthy(globalObject, "onError")) |onError_| {
+            if (try object.getTruthy(globalObject, "onError")) |onError_| {
                 if (!onError_.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the onError option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the onError option", .{});
                 }
                 const onError = onError_.withAsyncContextIfNeeded(globalObject);
                 handler.onError = onError;
                 onError.ensureStillAlive();
             }
 
-            if (object.getTruthy(globalObject, "ping")) |cb| {
+            if (try object.getTruthy(globalObject, "ping")) |cb| {
                 if (!cb.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the ping option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the ping option", .{});
                 }
                 handler.onPing = cb;
                 cb.ensureStillAlive();
                 valid = true;
             }
 
-            if (object.getTruthy(globalObject, "pong")) |cb| {
+            if (try object.getTruthy(globalObject, "pong")) |cb| {
                 if (!cb.isCallable(vm)) {
-                    globalObject.throwInvalidArguments("websocket expects a function for the pong option", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects a function for the pong option", .{});
                 }
                 handler.onPong = cb;
                 cb.ensureStillAlive();
@@ -4277,7 +4229,7 @@ pub const WebSocketServer = struct {
             if (valid)
                 return handler;
 
-            return null;
+            return globalObject.throwInvalidArguments2("WebSocketServer expects a message handler", .{});
         }
 
         pub fn protect(this: Handler) void {
@@ -4353,15 +4305,9 @@ pub const WebSocketServer = struct {
         .{ "256KB", uws.DEDICATED_COMPRESSOR_256KB },
     });
 
-    pub fn onCreate(globalObject: *JSC.JSGlobalObject, object: JSValue) ?WebSocketServer {
+    pub fn onCreate(globalObject: *JSC.JSGlobalObject, object: JSValue) bun.JSError!WebSocketServer {
         var server = WebSocketServer{};
-
-        if (Handler.fromJS(globalObject, object)) |handler| {
-            server.handler = handler;
-        } else {
-            globalObject.throwInvalidArguments("WebSocketServer expects a message handler", .{});
-            return null;
-        }
+        server.handler = try Handler.fromJS(globalObject, object);
 
         if (object.get(globalObject, "perMessageDeflate")) |per_message_deflate| {
             getter: {
@@ -4378,43 +4324,27 @@ pub const WebSocketServer = struct {
                     break :getter;
                 }
 
-                if (per_message_deflate.getTruthy(globalObject, "compress")) |compression| {
+                if (try per_message_deflate.getTruthy(globalObject, "compress")) |compression| {
                     if (compression.isBoolean()) {
                         server.compression |= if (compression.toBoolean()) uws.SHARED_COMPRESSOR else 0;
                     } else if (compression.isString()) {
                         server.compression |= CompressTable.getWithEql(compression.getZigString(globalObject), ZigString.eqlComptime) orelse {
-                            globalObject.throwInvalidArguments(
-                                "WebSocketServer expects a valid compress option, either disable \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"",
-                                .{},
-                            );
-                            return null;
+                            return globalObject.throwInvalidArguments2("WebSocketServer expects a valid compress option, either disable \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"", .{});
                         };
                     } else {
-                        globalObject.throwInvalidArguments(
-                            "websocket expects a valid compress option, either disable \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"",
-                            .{},
-                        );
-                        return null;
+                        return globalObject.throwInvalidArguments2("websocket expects a valid compress option, either disable \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"", .{});
                     }
                 }
 
-                if (per_message_deflate.getTruthy(globalObject, "decompress")) |compression| {
+                if (try per_message_deflate.getTruthy(globalObject, "decompress")) |compression| {
                     if (compression.isBoolean()) {
                         server.compression |= if (compression.toBoolean()) uws.SHARED_DECOMPRESSOR else 0;
                     } else if (compression.isString()) {
                         server.compression |= DecompressTable.getWithEql(compression.getZigString(globalObject), ZigString.eqlComptime) orelse {
-                            globalObject.throwInvalidArguments(
-                                "websocket expects a valid decompress option, either \"disable\" \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"",
-                                .{},
-                            );
-                            return null;
+                            return globalObject.throwInvalidArguments2("websocket expects a valid decompress option, either \"disable\" \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"", .{});
                         };
                     } else {
-                        globalObject.throwInvalidArguments(
-                            "websocket expects a valid decompress option, either \"disable\" \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"",
-                            .{},
-                        );
-                        return null;
+                        return globalObject.throwInvalidArguments2("websocket expects a valid decompress option, either \"disable\" \"shared\" \"dedicated\" \"3KB\" \"4KB\" \"8KB\" \"16KB\" \"32KB\" \"64KB\" \"128KB\" or \"256KB\"", .{});
                     }
                 }
             }
@@ -4423,8 +4353,7 @@ pub const WebSocketServer = struct {
         if (object.get(globalObject, "maxPayloadLength")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isAnyInt()) {
-                    globalObject.throwInvalidArguments("websocket expects maxPayloadLength to be an integer", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects maxPayloadLength to be an integer", .{});
                 }
                 server.maxPayloadLength = @truncate(@max(value.toInt64(), 0));
             }
@@ -4433,14 +4362,12 @@ pub const WebSocketServer = struct {
         if (object.get(globalObject, "idleTimeout")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isAnyInt()) {
-                    globalObject.throwInvalidArguments("websocket expects idleTimeout to be an integer", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects idleTimeout to be an integer", .{});
                 }
 
                 var idleTimeout: u16 = @truncate(@max(value.toInt64(), 0));
                 if (idleTimeout > 960) {
-                    globalObject.throwInvalidArguments("websocket expects idleTimeout to be 960 or less", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects idleTimeout to be 960 or less", .{});
                 } else if (idleTimeout > 0) {
                     // uws does not allow idleTimeout to be between (0, 8),
                     // since its timer is not that accurate, therefore round up.
@@ -4453,8 +4380,7 @@ pub const WebSocketServer = struct {
         if (object.get(globalObject, "backpressureLimit")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isAnyInt()) {
-                    globalObject.throwInvalidArguments("websocket expects backpressureLimit to be an integer", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects backpressureLimit to be an integer", .{});
                 }
 
                 server.backpressureLimit = @truncate(@max(value.toInt64(), 0));
@@ -4464,8 +4390,7 @@ pub const WebSocketServer = struct {
         if (object.get(globalObject, "closeOnBackpressureLimit")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isBoolean()) {
-                    globalObject.throwInvalidArguments("websocket expects closeOnBackpressureLimit to be a boolean", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects closeOnBackpressureLimit to be a boolean", .{});
                 }
 
                 server.closeOnBackpressureLimit = value.toBoolean();
@@ -4475,8 +4400,7 @@ pub const WebSocketServer = struct {
         if (object.get(globalObject, "sendPings")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isBoolean()) {
-                    globalObject.throwInvalidArguments("websocket expects sendPings to be a boolean", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects sendPings to be a boolean", .{});
                 }
 
                 server.sendPingsAutomatically = value.toBoolean();
@@ -4486,8 +4410,7 @@ pub const WebSocketServer = struct {
         if (object.get(globalObject, "publishToSelf")) |value| {
             if (!value.isUndefinedOrNull()) {
                 if (!value.isBoolean()) {
-                    globalObject.throwInvalidArguments("websocket expects publishToSelf to be a boolean", .{});
-                    return null;
+                    return globalObject.throwInvalidArguments2("websocket expects publishToSelf to be a boolean", .{});
                 }
 
                 server.handler.flags.publish_to_self = value.toBoolean();
@@ -4831,9 +4754,8 @@ pub const ServerWebSocket = struct {
         return uws.WebSocketBehavior.Wrap(ServerType, @This(), ssl).apply(opts);
     }
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*ServerWebSocket {
-        globalObject.throw("Cannot construct ServerWebSocket", .{});
-        return null;
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*ServerWebSocket {
+        return globalObject.throw2("Cannot construct ServerWebSocket", .{});
     }
 
     pub fn finalize(this: *ServerWebSocket) void {
@@ -4845,7 +4767,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(4);
         if (args.len < 1) {
             log("publish()", .{});
@@ -4878,7 +4800,7 @@ pub const ServerWebSocket = struct {
             return .zero;
         }
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
             globalThis.throw("publish expects compress to be a boolean", .{});
             return .zero;
         }
@@ -4930,7 +4852,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(4);
 
         if (args.len < 1) {
@@ -4960,7 +4882,7 @@ pub const ServerWebSocket = struct {
         var topic_slice = topic_value.toSlice(globalThis, bun.default_allocator);
         defer topic_slice.deinit();
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
             globalThis.throw("publishText expects compress to be a boolean", .{});
             return .zero;
         }
@@ -4993,7 +4915,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(4);
 
         if (args.len < 1) {
@@ -5026,7 +4948,7 @@ pub const ServerWebSocket = struct {
             return .zero;
         }
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
             globalThis.throw("publishBinary expects compress to be a boolean", .{});
             return .zero;
         }
@@ -5146,13 +5068,12 @@ pub const ServerWebSocket = struct {
         // Since we're passing the `this` value to the cork function, we need to
         // make sure the `this` value is up to date.
         this_value: JSC.JSValue,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(1);
         this.this_value = this_value;
 
         if (args.len < 1) {
-            globalThis.throwNotEnoughArguments("cork", 1, 0);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("cork", 1, 0);
         }
 
         const callback = args.ptr[0];
@@ -5185,7 +5106,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(2);
 
         if (args.len < 1) {
@@ -5202,7 +5123,7 @@ pub const ServerWebSocket = struct {
         const message_value = args.ptr[0];
         const compress_value = args.ptr[1];
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
             globalThis.throw("send expects compress to be a boolean", .{});
             return .zero;
         }
@@ -5259,7 +5180,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(2);
 
         if (args.len < 1) {
@@ -5276,7 +5197,7 @@ pub const ServerWebSocket = struct {
         const message_value = args.ptr[0];
         const compress_value = args.ptr[1];
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
             globalThis.throw("sendText expects compress to be a boolean", .{});
             return .zero;
         }
@@ -5343,7 +5264,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(2);
 
         if (args.len < 1) {
@@ -5360,7 +5281,7 @@ pub const ServerWebSocket = struct {
         const message_value = args.ptr[0];
         const compress_value = args.ptr[1];
 
-        if (!compress_value.isBoolean() and !compress_value.isUndefined() and !compress_value.isEmpty()) {
+        if (!compress_value.isBoolean() and !compress_value.isUndefined() and compress_value != .zero) {
             globalThis.throw("sendBinary expects compress to be a boolean", .{});
             return .zero;
         }
@@ -5421,7 +5342,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return sendPing(this, globalThis, callframe, "ping", .ping);
     }
 
@@ -5429,7 +5350,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return sendPing(this, globalThis, callframe, "pong", .pong);
     }
 
@@ -5543,7 +5464,7 @@ pub const ServerWebSocket = struct {
         callframe: *JSC.CallFrame,
         // Since close() can lead to the close() callback being called, let's always ensure the `this` value is up to date.
         this_value: JSC.JSValue,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(2);
         log("close()", .{});
         this.this_value = this_value;
@@ -5553,7 +5474,7 @@ pub const ServerWebSocket = struct {
         }
 
         const code = brk: {
-            if (args.ptr[0].isEmpty() or args.ptr[0].isUndefined()) {
+            if (args.ptr[0] == .zero or args.ptr[0].isUndefined()) {
                 // default exception code
                 break :brk 1000;
             }
@@ -5567,7 +5488,7 @@ pub const ServerWebSocket = struct {
         };
 
         var message_value: ZigString.Slice = brk: {
-            if (args.ptr[1].isEmpty() or args.ptr[1].isUndefined()) break :brk ZigString.Slice.empty;
+            if (args.ptr[1] == .zero or args.ptr[1].isUndefined()) break :brk ZigString.Slice.empty;
 
             if (args.ptr[1].toSliceOrNull(globalThis)) |slice| {
                 break :brk slice;
@@ -5590,7 +5511,7 @@ pub const ServerWebSocket = struct {
         callframe: *JSC.CallFrame,
         // Since terminate() can lead to close() being called, let's always ensure the `this` value is up to date.
         this_value: JSC.JSValue,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         _ = globalThis;
         const args = callframe.arguments(2);
         _ = args;
@@ -5630,7 +5551,8 @@ pub const ServerWebSocket = struct {
     ) callconv(.C) bool {
         log("setBinaryType()", .{});
 
-        switch (JSC.BinaryType.fromJSValue(globalThis, value) orelse
+        const btype = JSC.BinaryType.fromJSValue(globalThis, value) catch return false;
+        switch (btype orelse
             // some other value which we don't support
             .Float64Array) {
             .ArrayBuffer, .Buffer, .Uint8Array => |val| {
@@ -5648,7 +5570,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         log("getBufferedAmount()", .{});
 
         if (this.isClosed()) {
@@ -5661,7 +5583,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(1);
         if (args.len < 1) {
             globalThis.throw("subscribe requires at least 1 argument", .{});
@@ -5698,7 +5620,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(1);
         if (args.len < 1) {
             globalThis.throw("unsubscribe requires at least 1 argument", .{});
@@ -5735,7 +5657,7 @@ pub const ServerWebSocket = struct {
         this: *ServerWebSocket,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args = callframe.arguments(1);
         if (args.len < 1) {
             globalThis.throw("isSubscribed requires at least 1 argument", .{});
@@ -5806,7 +5728,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         thisObject: JSC.JSValue = JSC.JSValue.zero,
         /// Potentially null before listen() is called, and once .destroy() is called.
         app: ?*App = null,
-        vm: *JSC.VirtualMachine = undefined,
+        vm: *JSC.VirtualMachine,
         globalThis: *JSGlobalObject,
         base_url_string_for_joining: string = "",
         config: ServerConfig = ServerConfig{},
@@ -5827,6 +5749,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             has_handled_all_closed_promise: bool = false,
         } = .{},
 
+        dev_server: ?*bun.bake.DevServer,
+
         pub const doStop = JSC.wrapInstanceMethod(ThisServer, "stopFromJS", false);
         pub const dispose = JSC.wrapInstanceMethod(ThisServer, "disposeFromJS", false);
         pub const doUpgrade = JSC.wrapInstanceMethod(ThisServer, "onUpgrade", false);
@@ -5836,11 +5760,10 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
         pub const doRequestIP = JSC.wrapInstanceMethod(ThisServer, "requestIP", false);
         pub const doTimeout = JSC.wrapInstanceMethod(ThisServer, "timeout", false);
 
-        pub fn doSubscriberCount(this: *ThisServer, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn doSubscriberCount(this: *ThisServer, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(1);
             if (arguments.len < 1) {
-                globalThis.throwNotEnoughArguments("subscriberCount", 1, 0);
-                return .zero;
+                return globalThis.throwNotEnoughArguments("subscriberCount", 1, 0);
             }
 
             if (arguments.ptr[0].isEmptyOrUndefinedOrNull()) {
@@ -5858,15 +5781,14 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 return JSValue.jsNumber(0);
             }
 
-            return JSValue.jsNumber((this.app.?.num_subscribers(topic.slice())));
+            return JSValue.jsNumber((this.app.?.numSubscribers(topic.slice())));
         }
 
         pub usingnamespace NamespaceType;
         pub usingnamespace bun.New(@This());
 
-        pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*ThisServer {
-            globalThis.throw("Server() is not a constructor", .{});
-            return null;
+        pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*ThisServer {
+            return globalThis.throw("Server() is not a constructor", .{});
         }
 
         extern fn JSSocketAddress__create(global: *JSC.JSGlobalObject, ip: JSValue, port: i32, is_ipv6: bool) JSValue;
@@ -5900,7 +5822,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             this.config.idleTimeout = @truncate(@min(seconds, 255));
         }
 
-        pub fn publish(this: *ThisServer, globalThis: *JSC.JSGlobalObject, topic: ZigString, message_value: JSValue, compress_value: ?JSValue, exception: JSC.C.ExceptionRef) JSValue {
+        pub fn publish(this: *ThisServer, globalThis: *JSC.JSGlobalObject, topic: ZigString, message_value: JSValue, compress_value: ?JSValue) JSValue {
             if (this.config.websocket == null)
                 return JSValue.jsNumber(0);
 
@@ -5908,14 +5830,14 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
             if (topic.len == 0) {
                 httplog("publish() topic invalid", .{});
-                exception.* = JSC.createError(globalThis, "publish requires a topic string", .{}).asObjectRef();
+                globalThis.throw("publish requires a topic string", .{});
                 return .zero;
             }
 
             var topic_slice = topic.toSlice(bun.default_allocator);
             defer topic_slice.deinit();
             if (topic_slice.len == 0) {
-                exception.* = JSC.createError(globalThis, "publish requires a non-empty topic", .{}).asObjectRef();
+                globalThis.throw("publish requires a non-empty topic", .{});
                 return .zero;
             }
 
@@ -5949,11 +5871,10 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             globalThis: *JSC.JSGlobalObject,
             object: JSC.JSValue,
             optional: ?JSValue,
-            exception: js.ExceptionRef,
-        ) JSValue {
+        ) bun.JSError!JSValue {
             if (this.config.websocket == null) {
-                JSC.throwInvalidArguments("To enable websocket support, set the \"websocket\" object in Bun.serve({})", .{}, globalThis, exception);
-                return JSValue.jsUndefined();
+                globalThis.throwInvalidArguments("To enable websocket support, set the \"websocket\" object in Bun.serve({})", .{});
+                return error.JSError;
             }
 
             if (this.flags.terminated) {
@@ -5961,8 +5882,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             }
 
             var request = object.as(Request) orelse {
-                JSC.throwInvalidArguments("upgrade requires a Request object", .{}, globalThis, exception);
-                return JSValue.jsUndefined();
+                globalThis.throwInvalidArguments("upgrade requires a Request object", .{});
+                return error.JSError;
             };
 
             var upgrader = request.request_context.get(RequestContext) orelse return JSC.jsBoolean(false);
@@ -6033,8 +5954,8 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     }
 
                     if (!opts.isObject()) {
-                        JSC.throwInvalidArguments("upgrade options must be an object", .{}, globalThis, exception);
-                        return JSValue.jsUndefined();
+                        globalThis.throwInvalidArguments("upgrade options must be an object", .{});
+                        return error.JSError;
                     }
 
                     if (opts.fastGet(globalThis, .data)) |headers_value| {
@@ -6042,7 +5963,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     }
 
                     if (globalThis.hasException()) {
-                        return JSValue.jsUndefined();
+                        return error.JSError;
                     }
 
                     if (opts.fastGet(globalThis, .headers)) |headers_value| {
@@ -6060,13 +5981,13 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                             break :brk null;
                         } orelse {
                             if (!globalThis.hasException()) {
-                                JSC.throwInvalidArguments("upgrade options.headers must be a Headers or an object", .{}, globalThis, exception);
+                                globalThis.throwInvalidArguments("upgrade options.headers must be a Headers or an object", .{});
                             }
-                            return JSValue.jsUndefined();
+                            return error.JSError;
                         };
 
                         if (globalThis.hasException()) {
-                            return JSValue.jsUndefined();
+                            return error.JSError;
                         }
 
                         if (fetch_headers_to_use.fastGet(.SecWebSocketProtocol)) |protocol| {
@@ -6084,7 +6005,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     }
 
                     if (globalThis.hasException()) {
-                        return JSValue.jsUndefined();
+                        return error.JSError;
                     }
                 }
             }
@@ -6161,32 +6082,20 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             this.setRoutes();
         }
 
-        pub fn onReload(
-            this: *ThisServer,
-            globalThis: *JSC.JSGlobalObject,
-            callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        pub fn onReload(this: *ThisServer, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(1).slice();
             if (arguments.len < 1) {
-                globalThis.throwNotEnoughArguments("reload", 1, 0);
-                return .zero;
+                return globalThis.throwNotEnoughArguments("reload", 1, 0);
             }
 
             var args_slice = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments);
             defer args_slice.deinit();
-            var exception_ref = [_]JSC.C.JSValueRef{null};
-            const exception: JSC.C.ExceptionRef = &exception_ref;
 
             var new_config: ServerConfig = .{};
-            ServerConfig.fromJS(globalThis, &new_config, &args_slice, exception);
-            if (exception.* != null) {
-                new_config.deinit();
-                globalThis.throwValue(exception_ref[0].?.value());
-                return .zero;
-            }
+            try ServerConfig.fromJS(globalThis, &new_config, &args_slice, false);
             if (globalThis.hasException()) {
                 new_config.deinit();
-                return .zero;
+                return error.JSError;
             }
 
             this.onReloadFromZig(&new_config, globalThis);
@@ -6198,7 +6107,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             this: *ThisServer,
             ctx: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
             const arguments = callframe.arguments(2).slice();
             if (arguments.len == 0) {
@@ -6240,22 +6149,22 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
                 if (arguments.len >= 2 and arguments[1].isObject()) {
                     var opts = arguments[1];
-                    if (opts.fastGet(ctx.ptr(), .method)) |method_| {
-                        var slice_ = method_.toSlice(ctx.ptr(), getAllocator(ctx));
+                    if (opts.fastGet(ctx, .method)) |method_| {
+                        var slice_ = method_.toSlice(ctx, getAllocator(ctx));
                         defer slice_.deinit();
                         method = HTTP.Method.which(slice_.slice()) orelse method;
                     }
 
-                    if (opts.fastGet(ctx.ptr(), .headers)) |headers_| {
+                    if (opts.fastGet(ctx, .headers)) |headers_| {
                         if (headers_.as(JSC.FetchHeaders)) |headers__| {
                             headers = headers__;
-                        } else if (JSC.FetchHeaders.createFromJS(ctx.ptr(), headers_)) |headers__| {
+                        } else if (JSC.FetchHeaders.createFromJS(ctx, headers_)) |headers__| {
                             headers = headers__;
                         }
                     }
 
-                    if (opts.fastGet(ctx.ptr(), .body)) |body__| {
-                        if (Blob.get(ctx.ptr(), body__, true, false)) |new_blob| {
+                    if (opts.fastGet(ctx, .body)) |body__| {
+                        if (Blob.get(ctx, body__, true, false)) |new_blob| {
                             body = .{ .Blob = new_blob };
                         } else |_| {
                             return JSPromise.rejectedPromiseValue(ctx, ZigString.init("fetch() received invalid body").toErrorInstance(ctx));
@@ -6618,20 +6527,49 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 app.destroy();
             }
 
+            if (this.dev_server) |dev_server| {
+                dev_server.deinit();
+            }
+
             this.destroy();
         }
 
-        pub fn init(config: ServerConfig, globalThis: *JSGlobalObject) *ThisServer {
+        pub fn init(config: ServerConfig, global: *JSGlobalObject) bun.JSOOM!*ThisServer {
+            const base_url = try bun.default_allocator.dupe(u8, strings.trim(config.base_url.href, "/"));
+            errdefer bun.default_allocator.free(base_url);
+
+            const dev_server = if (bun.FeatureFlags.bake) if (config.bake) |bake_options| dev_server: {
+                bun.Output.warn(
+                    \\Be advised that Bun Bake is highly experimental, and its API
+                    \\will have breaking changes. Join the <magenta>#bake<r> Discord
+                    \\channel to help us find bugs: <blue>https://bun.sh/discord<r>
+                    \\
+                    \\
+                , .{});
+                bun.Output.flush();
+
+                break :dev_server bun.bake.DevServer.init(.{
+                    .root = bake_options.root,
+                    .framework = bake_options.framework,
+                    .vm = global.bunVM(),
+                }) catch |err| {
+                    global.throwError(err, "while initializing Bun Dev Server");
+                    return error.JSError;
+                };
+            } else null else null;
+            errdefer if (dev_server) |d| d.deinit();
+
             var server = ThisServer.new(.{
-                .globalThis = globalThis,
+                .globalThis = global,
                 .config = config,
-                .base_url_string_for_joining = bun.default_allocator.dupe(u8, strings.trim(config.base_url.href, "/")) catch unreachable,
+                .base_url_string_for_joining = base_url,
                 .vm = JSC.VirtualMachine.get(),
                 .allocator = Arena.getThreadlocalDefault(),
+                .dev_server = dev_server,
             });
 
             if (RequestContext.pool == null) {
-                RequestContext.pool = server.allocator.create(RequestContext.RequestContextStackAllocator) catch bun.outOfMemory();
+                RequestContext.pool = try server.allocator.create(RequestContext.RequestContextStackAllocator);
                 RequestContext.pool.?.* = RequestContext.RequestContextStackAllocator.init(
                     if (comptime bun.heap_breakdown.enabled)
                         bun.typedAllocator(RequestContext)
@@ -6781,14 +6719,14 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             this.poll_ref.unref(this.vm);
         }
 
-        pub fn doRef(this: *ThisServer, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn doRef(this: *ThisServer, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const this_value = callframe.this();
             this.ref();
 
             return this_value;
         }
 
-        pub fn doUnref(this: *ThisServer, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn doUnref(this: *ThisServer, _: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const this_value = callframe.this();
             this.unref();
 
@@ -6879,11 +6817,128 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             return false;
         }
 
-        pub fn onRequest(
+        pub fn onRequest(this: *ThisServer, req: *uws.Request, resp: *App.Response) void {
+            const prepared = this.prepareJsRequestContext(req, resp) orelse return;
+            const ctx = prepared.ctx;
+
+            bun.assert(this.config.onRequest != .zero);
+            const response_value = this.config.onRequest.call(this.globalThis, this.thisObject, &.{
+                prepared.js_request,
+                this.thisObject,
+            }) catch |err|
+                this.globalThis.takeException(err);
+
+            defer {
+                // uWS request will not live longer than this function
+                prepared.request_object.request_context.detachRequest();
+            }
+            const original_state = ctx.defer_deinit_until_callback_completes;
+            var should_deinit_context = false;
+            ctx.defer_deinit_until_callback_completes = &should_deinit_context;
+            ctx.onResponse(this, prepared.js_request, response_value);
+            ctx.defer_deinit_until_callback_completes = original_state;
+
+            // Reference in the stack here in case it is not for whatever reason
+            prepared.js_request.ensureStillAlive();
+
+            if (should_deinit_context) {
+                ctx.deinit();
+                return;
+            }
+
+            if (ctx.shouldRenderMissing()) {
+                ctx.renderMissing();
+                return;
+            }
+
+            // The request is asynchronous, and all information from `req` must be copied
+            // since the provided uws.Request will be re-used for future requests (stack allocated).
+            ctx.toAsync(req, prepared.request_object);
+        }
+
+        pub fn onRequestFromSaved(
             this: *ThisServer,
-            req: *uws.Request,
+            req: SavedRequest.Union,
             resp: *App.Response,
+            callback: JSValue,
+            comptime arg_count: comptime_int,
+            extra_args: [arg_count]JSValue,
         ) void {
+            const prepared: PreparedRequest = switch (req) {
+                .stack => |r| this.prepareJsRequestContext(r, resp) orelse return,
+                .saved => |data| .{
+                    .js_request = data.js_request.get() orelse @panic("Request was unexpectedly freed"),
+                    .request_object = data.request,
+                    .ctx = data.ctx.tagged_pointer.as(RequestContext),
+                },
+            };
+            const ctx = prepared.ctx;
+
+            bun.assert(callback != .zero);
+            const args = .{prepared.js_request} ++ extra_args;
+            const response_value = callback.call(this.globalThis, this.thisObject, &args) catch |err|
+                this.globalThis.takeException(err);
+
+            defer if (req == .stack) {
+                // uWS request will not live longer than this function
+                prepared.request_object.request_context.detachRequest();
+            };
+            const original_state = ctx.defer_deinit_until_callback_completes;
+            var should_deinit_context = false;
+            ctx.defer_deinit_until_callback_completes = &should_deinit_context;
+            ctx.onResponse(this, prepared.js_request, response_value);
+            ctx.defer_deinit_until_callback_completes = original_state;
+
+            // Reference in the stack here in case it is not for whatever reason
+            prepared.js_request.ensureStillAlive();
+
+            if (should_deinit_context) {
+                ctx.deinit();
+                return;
+            }
+
+            if (ctx.shouldRenderMissing()) {
+                ctx.renderMissing();
+                return;
+            }
+
+            // The request is asynchronous, and all information from `req` must be copied
+            // since the provided uws.Request will be re-used for future requests (stack allocated).
+            switch (req) {
+                .stack => |r| ctx.toAsync(r, prepared.request_object),
+                .saved => {}, // info already copied
+            }
+        }
+
+        pub const PreparedRequest = struct {
+            js_request: JSValue,
+            request_object: *Request,
+            ctx: *RequestContext,
+
+            /// This is used by DevServer for deferring calling the JS handler
+            /// to until the bundle is actually ready.
+            pub fn save(
+                prepared: PreparedRequest,
+                global: *JSC.JSGlobalObject,
+                req: *uws.Request,
+                resp: *App.Response,
+            ) SavedRequest {
+                _ = resp; // autofix
+                // By saving a request, all information from `req` must be
+                // copied since the provided uws.Request will be re-used for
+                // future requests (stack allocated).
+                prepared.ctx.toAsync(req, prepared.request_object);
+
+                return .{
+                    .js_request = JSC.Strong.create(prepared.js_request, global),
+                    .request = prepared.request_object,
+                    .ctx = AnyRequestContext.init(prepared.ctx),
+                    .response = uws.AnyResponse,
+                };
+            }
+        };
+
+        pub fn prepareJsRequestContext(this: *ThisServer, req: *uws.Request, resp: *App.Response) ?PreparedRequest {
             JSC.markBinding(@src());
             this.onPendingRequest();
             if (comptime Environment.isDebug) {
@@ -6904,10 +6959,10 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 resp.onTimeout(*anyopaque, onTimeoutForIdleWarn, &did_send_idletimeout_warning_once);
             }
 
-            var ctx = this.request_pool_allocator.tryGet() catch bun.outOfMemory();
+            const ctx = this.request_pool_allocator.tryGet() catch bun.outOfMemory();
             ctx.create(this, req, resp);
             this.vm.jsc.reportExtraMemory(@sizeOf(RequestContext));
-            var body = this.vm.initRequestBodyValue(.{ .Null = {} }) catch unreachable;
+            const body = this.vm.initRequestBodyValue(.{ .Null = {} }) catch unreachable;
 
             ctx.request_body = body;
             var signal = JSC.WebCore.AbortSignal.new(this.globalThis);
@@ -6951,7 +7006,7 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     resp.writeStatus("413 Request Entity Too Large");
                     resp.endWithoutBody(true);
                     this.finalize();
-                    return;
+                    return null;
                 }
 
                 ctx.request_body_content_len = req_len;
@@ -6974,47 +7029,12 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     resp.onData(*RequestContext, RequestContext.onBufferedBodyChunk, ctx);
                 }
             }
-            const js_request = request_object.toJS(this.globalThis);
-            js_request.ensureStillAlive();
 
-            // We keep the Request object alive for the duration of the request so that we can remove the pointer to the UWS request object.
-            var args = [_]JSC.JSValue{
-                js_request,
-                this.thisObject,
+            return .{
+                .js_request = request_object.toJS(this.globalThis),
+                .request_object = request_object,
+                .ctx = ctx,
             };
-
-            const request_value = args[0];
-            request_value.ensureStillAlive();
-
-            const response_value = this.config.onRequest.call(this.globalThis, this.thisObject, &args) catch |err|
-                this.globalThis.takeException(err);
-            defer {
-                // uWS request will not live longer than this function
-                request_object.request_context.detachRequest();
-            }
-            const original_state = ctx.defer_deinit_until_callback_completes;
-            var should_deinit_context = false;
-            ctx.defer_deinit_until_callback_completes = &should_deinit_context;
-            ctx.onResponse(
-                this,
-                req,
-                request_object,
-                request_value,
-                response_value,
-            );
-            ctx.defer_deinit_until_callback_completes = original_state;
-
-            if (should_deinit_context) {
-                ctx.deinit();
-                return;
-            }
-
-            if (ctx.shouldRenderMissing()) {
-                ctx.renderMissing();
-                return;
-            }
-
-            ctx.toAsync(req, request_object);
         }
 
         pub fn onWebSocketUpgrade(
@@ -7063,8 +7083,6 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             ctx.defer_deinit_until_callback_completes = &should_deinit_context;
             ctx.onResponse(
                 this,
-                req,
-                request_object,
                 request_value,
                 response_value,
             );
@@ -7105,8 +7123,6 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 );
             }
 
-            app.any("/*", *ThisServer, this, onRequest);
-
             if (comptime debug_mode) {
                 app.get("/bun:info", *ThisServer, this, onBunInfoRequest);
                 if (this.config.inspector) {
@@ -7116,8 +7132,16 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
 
                 app.get("/src:/*", *ThisServer, this, onSrcRequest);
             }
+
+            if (this.dev_server) |dev| {
+                dev.attachRoutes(this) catch bun.outOfMemory();
+            } else {
+                bun.assert(this.config.onRequest != .zero);
+                app.any("/*", *ThisServer, this, onRequest);
+            }
         }
 
+        // TODO: make this return JSError!void, and do not deinitialize on synchronous failure, to allow errdefer in caller scope
         pub fn listen(this: *ThisServer) void {
             httplog("listen", .{});
             var app: *App = undefined;
@@ -7265,6 +7289,17 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
     };
 }
 
+pub const SavedRequest = struct {
+    js_request: JSC.Strong,
+    request: *Request,
+    ctx: AnyRequestContext,
+
+    pub const Union = union(enum) {
+        stack: *uws.Request,
+        saved: bun.JSC.API.SavedRequest,
+    };
+};
+
 pub const ServerAllConnectionsClosedTask = struct {
     globalObject: *JSC.JSGlobalObject,
     promise: JSC.JSPromise.Strong,
@@ -7294,7 +7329,7 @@ pub const HTTPServer = NewServer(JSC.Codegen.JSHTTPServer, false, false);
 pub const HTTPSServer = NewServer(JSC.Codegen.JSHTTPSServer, true, false);
 pub const DebugHTTPServer = NewServer(JSC.Codegen.JSDebugHTTPServer, false, true);
 pub const DebugHTTPSServer = NewServer(JSC.Codegen.JSDebugHTTPSServer, true, true);
-const AnyServer = union(enum) {
+pub const AnyServer = union(enum) {
     HTTPServer: *HTTPServer,
     HTTPSServer: *HTTPSServer,
     DebugHTTPServer: *DebugHTTPServer,
@@ -7308,11 +7343,11 @@ const AnyServer = union(enum) {
 
     pub fn from(server: anytype) AnyServer {
         return switch (@TypeOf(server)) {
-            *HTTPServer => AnyServer{ .HTTPServer = server },
-            *HTTPSServer => AnyServer{ .HTTPSServer = server },
-            *DebugHTTPServer => AnyServer{ .DebugHTTPServer = server },
-            *DebugHTTPSServer => AnyServer{ .DebugHTTPSServer = server },
-            else => @compileError("Invalid server type"),
+            *HTTPServer => .{ .HTTPServer = server },
+            *HTTPSServer => .{ .HTTPSServer = server },
+            *DebugHTTPServer => .{ .DebugHTTPServer = server },
+            *DebugHTTPSServer => .{ .DebugHTTPSServer = server },
+            else => |T| @compileError("Invalid server type: " ++ @typeName(T)),
         };
     }
 
@@ -7333,6 +7368,34 @@ const AnyServer = union(enum) {
             inline else => |server| server.onStaticRequestComplete(),
         }
     }
+
+    pub fn publish(this: AnyServer, topic: []const u8, message: []const u8, opcode: uws.Opcode, compress: bool) bool {
+        return switch (this) {
+            inline else => |server| server.app.?.publish(topic, message, opcode, compress),
+        };
+    }
+
+    // TODO: support TLS
+    pub fn onRequestFromSaved(
+        this: AnyServer,
+        req: SavedRequest.Union,
+        resp: *uws.NewApp(false).Response,
+        callback: JSC.JSValue,
+        comptime extra_arg_count: usize,
+        extra_args: [extra_arg_count]JSValue,
+    ) void {
+        return switch (this) {
+            inline else => |server| server.onRequestFromSaved(req, resp, callback, extra_arg_count, extra_args),
+            .HTTPSServer => @panic("TODO: https"),
+            .DebugHTTPSServer => @panic("TODO: https"),
+        };
+    }
+
+    pub fn numSubscribers(this: AnyServer, topic: []const u8) u32 {
+        return switch (this) {
+            inline else => |server| server.app.?.numSubscribers(topic),
+        };
+    }
 };
 const welcome_page_html_gz = @embedFile("welcome-page.html.gz");
 
diff --git a/src/bun.js/base.zig b/src/bun.js/base.zig
index 461d6f0112a706..3ad21e6131231e 100644
--- a/src/bun.js/base.zig
+++ b/src/bun.js/base.zig
@@ -193,7 +193,7 @@ fn toTypeErrorWithCode(
         zig_str.mark();
     }
     const code_str = ZigString.init(code);
-    return JSC.JSValue.createTypeError(&zig_str, &code_str, ctx.ptr());
+    return JSC.JSValue.createTypeError(&zig_str, &code_str, ctx);
 }
 
 pub fn toTypeError(
@@ -413,7 +413,8 @@ pub const ArrayBuffer = extern struct {
 
     pub fn fromTypedArray(ctx: JSC.C.JSContextRef, value: JSC.JSValue) ArrayBuffer {
         var out = std.mem.zeroes(ArrayBuffer);
-        bun.assert(value.asArrayBuffer_(ctx.ptr(), &out));
+        const was = value.asArrayBuffer_(ctx, &out);
+        bun.assert(was);
         out.value = value;
         return out;
     }
@@ -479,7 +480,7 @@ pub const ArrayBuffer = extern struct {
     const log = Output.scoped(.ArrayBuffer, false);
 
     pub fn toJS(this: ArrayBuffer, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) JSC.JSValue {
-        if (!this.value.isEmpty()) {
+        if (this.value != .zero) {
             return this.value;
         }
 
@@ -519,7 +520,7 @@ pub const ArrayBuffer = extern struct {
         callback: JSC.C.JSTypedArrayBytesDeallocator,
         exception: JSC.C.ExceptionRef,
     ) JSC.JSValue {
-        if (!this.value.isEmpty()) {
+        if (this.value != .zero) {
             return this.value;
         }
 
@@ -605,7 +606,7 @@ pub const MarkedArrayBuffer = struct {
         return MarkedArrayBuffer.fromBytes(buf, allocator, JSC.JSValue.JSType.Uint8Array);
     }
 
-    pub fn fromJS(global: *JSC.JSGlobalObject, value: JSC.JSValue, _: JSC.C.ExceptionRef) ?MarkedArrayBuffer {
+    pub fn fromJS(global: *JSC.JSGlobalObject, value: JSC.JSValue) ?MarkedArrayBuffer {
         const array_buffer = value.asArrayBuffer(global) orelse return null;
         return MarkedArrayBuffer{ .buffer = array_buffer, .allocator = null };
     }
@@ -979,16 +980,13 @@ pub fn DOMCall(
             if (!JSC.is_bindgen) {
                 @export(slowpath, .{ .name = shim.symbolName("slowpath") });
                 @export(fastpath, .{ .name = shim.symbolName("fastpath") });
-            } else {
-                _ = slowpath;
-                _ = fastpath;
             }
         }
     };
 }
 
 pub fn InstanceMethodType(comptime Container: type) type {
-    return fn (instance: *Container, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue;
+    return fn (instance: *Container, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue;
 }
 
 pub fn wrapInstanceMethod(
@@ -1006,7 +1004,7 @@ pub fn wrapInstanceMethod(
             this: *Container,
             globalThis: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) callconv(JSC.conv) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(FunctionTypeInfo.params.len);
             var iter = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
             var args: Args = undefined;
@@ -1030,7 +1028,7 @@ pub fn wrapInstanceMethod(
                         args[i] = this;
                     },
                     *JSC.JSGlobalObject => {
-                        args[i] = globalThis.ptr();
+                        args[i] = globalThis;
                     },
                     *JSC.CallFrame => {
                         args[i] = callframe;
@@ -1041,7 +1039,7 @@ pub fn wrapInstanceMethod(
                             iter.deinit();
                             return JSC.JSValue.zero;
                         };
-                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
+                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                             globalThis.throwInvalidArguments("expected string or buffer", .{});
                             iter.deinit();
                             return JSC.JSValue.zero;
@@ -1050,7 +1048,7 @@ pub fn wrapInstanceMethod(
                     ?JSC.Node.StringOrBuffer => {
                         if (iter.nextEat()) |arg| {
                             if (!arg.isEmptyOrUndefinedOrNull()) {
-                                args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
+                                args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                                     globalThis.throwInvalidArguments("expected string or buffer", .{});
                                     iter.deinit();
                                     return JSC.JSValue.zero;
@@ -1064,7 +1062,7 @@ pub fn wrapInstanceMethod(
                     },
                     JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 globalThis.throwInvalidArguments("expected TypedArray", .{});
                                 iter.deinit();
                                 return JSC.JSValue.zero;
@@ -1077,7 +1075,7 @@ pub fn wrapInstanceMethod(
                     },
                     ?JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 globalThis.throwInvalidArguments("expected TypedArray", .{});
                                 iter.deinit();
                                 return JSC.JSValue.zero;
@@ -1099,11 +1097,11 @@ pub fn wrapInstanceMethod(
                             return JSC.JSValue.zero;
                         }
 
-                        args[i] = string_value.getZigString(globalThis.ptr());
+                        args[i] = string_value.getZigString(globalThis);
                     },
                     ?JSC.Cloudflare.ContentOptions => {
                         if (iter.nextEat()) |content_arg| {
-                            if (content_arg.get(globalThis.ptr(), "html")) |html_val| {
+                            if (content_arg.get(globalThis, "html")) |html_val| {
                                 args[i] = .{ .html = html_val.toBoolean() };
                             }
                         } else {
@@ -1169,7 +1167,7 @@ pub fn wrapStaticMethod(
     comptime Container: type,
     comptime name: string,
     comptime auto_protect: bool,
-) JSC.Codegen.StaticCallbackType {
+) JSC.JSHostZigFunction {
     return struct {
         const FunctionType = @TypeOf(@field(Container, name));
         const FunctionTypeInfo: std.builtin.Type.Fn = @typeInfo(FunctionType).Fn;
@@ -1179,7 +1177,7 @@ pub fn wrapStaticMethod(
         pub fn method(
             globalThis: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) callconv(JSC.conv) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(FunctionTypeInfo.params.len);
             var iter = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments.slice());
             var args: Args = undefined;
@@ -1188,7 +1186,7 @@ pub fn wrapStaticMethod(
                 const ArgType = param.type.?;
                 switch (param.type.?) {
                     *JSC.JSGlobalObject => {
-                        args[i] = globalThis.ptr();
+                        args[i] = globalThis;
                     },
                     JSC.Node.StringOrBuffer => {
                         const arg = iter.nextEat() orelse {
@@ -1196,7 +1194,7 @@ pub fn wrapStaticMethod(
                             iter.deinit();
                             return JSC.JSValue.zero;
                         };
-                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
+                        args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                             globalThis.throwInvalidArguments("expected string or buffer", .{});
                             iter.deinit();
                             return JSC.JSValue.zero;
@@ -1204,7 +1202,7 @@ pub fn wrapStaticMethod(
                     },
                     ?JSC.Node.StringOrBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse brk: {
+                            args[i] = JSC.Node.StringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse brk: {
                                 if (arg == .undefined) {
                                     break :brk null;
                                 }
@@ -1219,7 +1217,7 @@ pub fn wrapStaticMethod(
                     },
                     JSC.Node.BlobOrStringOrBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = JSC.Node.BlobOrStringOrBuffer.fromJS(globalThis.ptr(), iter.arena.allocator(), arg) orelse {
+                            args[i] = JSC.Node.BlobOrStringOrBuffer.fromJS(globalThis, iter.arena.allocator(), arg) orelse {
                                 globalThis.throwInvalidArguments("expected blob, string or buffer", .{});
                                 iter.deinit();
                                 return JSC.JSValue.zero;
@@ -1232,7 +1230,7 @@ pub fn wrapStaticMethod(
                     },
                     JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 globalThis.throwInvalidArguments("expected TypedArray", .{});
                                 iter.deinit();
                                 return JSC.JSValue.zero;
@@ -1245,7 +1243,7 @@ pub fn wrapStaticMethod(
                     },
                     ?JSC.ArrayBuffer => {
                         if (iter.nextEat()) |arg| {
-                            args[i] = arg.asArrayBuffer(globalThis.ptr()) orelse {
+                            args[i] = arg.asArrayBuffer(globalThis) orelse {
                                 globalThis.throwInvalidArguments("expected TypedArray", .{});
                                 iter.deinit();
                                 return JSC.JSValue.zero;
@@ -1267,11 +1265,11 @@ pub fn wrapStaticMethod(
                             return JSC.JSValue.zero;
                         }
 
-                        args[i] = string_value.getZigString(globalThis.ptr());
+                        args[i] = string_value.getZigString(globalThis);
                     },
                     ?JSC.Cloudflare.ContentOptions => {
                         if (iter.nextEat()) |content_arg| {
-                            if (content_arg.get(globalThis.ptr(), "html")) |html_val| {
+                            if (content_arg.get(globalThis, "html")) |html_val| {
                                 args[i] = .{ .html = html_val.toBoolean() };
                             }
                         } else {
@@ -1419,9 +1417,9 @@ pub const BinaryType = enum(u4) {
         return Map.get(input);
     }
 
-    pub fn fromJSValue(globalThis: *JSC.JSGlobalObject, input: JSValue) ?BinaryType {
+    pub fn fromJSValue(globalThis: *JSC.JSGlobalObject, input: JSValue) bun.JSError!?BinaryType {
         if (input.isString()) {
-            return Map.getWithEql(input.getZigString(globalThis), ZigString.eqlComptime);
+            return Map.getWithEql(try input.toBunString2(globalThis), bun.String.eqlComptime);
         }
 
         return null;
diff --git a/src/bun.js/bindings/BunInjectedScriptHost.cpp b/src/bun.js/bindings/BunInjectedScriptHost.cpp
index 13c7a48febf97a..b044e9bce1e616 100644
--- a/src/bun.js/bindings/BunInjectedScriptHost.cpp
+++ b/src/bun.js/bindings/BunInjectedScriptHost.cpp
@@ -144,16 +144,16 @@ JSValue BunInjectedScriptHost::getInternalProperties(VM& vm, JSGlobalObject* exe
                 return array;
             }
 
-            if (auto* params = jsDynamicCast<JSURLSearchParams*>(value)) {
+            if (auto* formData = jsDynamicCast<JSDOMFormData*>(value)) {
                 auto* array = constructEmptyArray(exec, nullptr);
-                constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, params));
+                constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, formData));
                 RETURN_IF_EXCEPTION(scope, {});
                 return array;
             }
-
-            if (auto* formData = jsDynamicCast<JSDOMFormData*>(value)) {
+        } else if (type == JSAsJSONType) {
+            if (auto* params = jsDynamicCast<JSURLSearchParams*>(value)) {
                 auto* array = constructEmptyArray(exec, nullptr);
-                constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, formData));
+                constructDataProperties(vm, exec, array, WebCore::getInternalProperties(vm, exec, params));
                 RETURN_IF_EXCEPTION(scope, {});
                 return array;
             }
diff --git a/src/bun.js/bindings/BunJSCEventLoop.cpp b/src/bun.js/bindings/BunJSCEventLoop.cpp
index 7a3cf95b2a01ee..30498f1be9157e 100644
--- a/src/bun.js/bindings/BunJSCEventLoop.cpp
+++ b/src/bun.js/bindings/BunJSCEventLoop.cpp
@@ -5,14 +5,19 @@
 
 extern "C" int Bun__JSC_onBeforeWait(JSC::VM* vm)
 {
-    if (vm->heap.hasAccess()) {
-        vm->heap.releaseAccess();
-        return 1;
-    }
+    UNUSED_PARAM(vm);
+    // TODO: use JSC timers, run the incremental sweeper.
+    // That will fix this.
+    // In the meantime, we're disabling this due to https://github.com/oven-sh/bun/issues/14982
+    // if (vm->heap.hasAccess()) {
+    //     vm->heap.releaseAccess();
+    //     return 1;
+    // }
     return 0;
 }
 
 extern "C" void Bun__JSC_onAfterWait(JSC::VM* vm)
 {
-    vm->heap.acquireAccess();
+    UNUSED_PARAM(vm);
+    // vm->heap.acquireAccess();
 }
diff --git a/src/bun.js/bindings/BunObject.cpp b/src/bun.js/bindings/BunObject.cpp
index ec7315754a7efc..b48c9dfe92c847 100644
--- a/src/bun.js/bindings/BunObject.cpp
+++ b/src/bun.js/bindings/BunObject.cpp
@@ -278,6 +278,15 @@ static JSValue constructPluginObject(VM& vm, JSObject* bunObject)
     return pluginFunction;
 }
 
+static JSValue constructBunSQLObject(VM& vm, JSObject* bunObject)
+{
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto* globalObject = defaultGlobalObject(bunObject->globalObject());
+    JSValue sqlValue = globalObject->internalModuleRegistry()->requireId(globalObject, vm, InternalModuleRegistry::BunSql);
+    RETURN_IF_EXCEPTION(scope, {});
+    return sqlValue.getObject()->get(globalObject, vm.propertyNames->defaultKeyword);
+}
+
 extern "C" JSC::EncodedJSValue JSPasswordObject__create(JSGlobalObject*);
 
 static JSValue constructPasswordObject(VM& vm, JSObject* bunObject)
@@ -630,6 +639,7 @@ JSC_DEFINE_HOST_FUNCTION(functionFileURLToPath, (JSC::JSGlobalObject * globalObj
     resolveSync                                    BunObject_callback_resolveSync                                      DontDelete|Function 1
     revision                                       constructBunRevision                                                ReadOnly|DontDelete|PropertyCallback
     semver                                         BunObject_getter_wrap_semver                                        ReadOnly|DontDelete|PropertyCallback
+    sql                                            constructBunSQLObject                                               DontDelete|PropertyCallback
     serve                                          BunObject_callback_serve                                            DontDelete|Function 1
     sha                                            BunObject_callback_sha                                              DontDelete|Function 1
     shrink                                         BunObject_callback_shrink                                           DontDelete|Function 1
diff --git a/src/bun.js/bindings/BunProcess.cpp b/src/bun.js/bindings/BunProcess.cpp
index bd43710356ec9f..f933d59c49d5dc 100644
--- a/src/bun.js/bindings/BunProcess.cpp
+++ b/src/bun.js/bindings/BunProcess.cpp
@@ -114,7 +114,6 @@ JSC_DECLARE_CUSTOM_GETTER(Process_getPID);
 JSC_DECLARE_CUSTOM_GETTER(Process_getPPID);
 JSC_DECLARE_HOST_FUNCTION(Process_functionCwd);
 JSC_DEFINE_HOST_FUNCTION(jsFunction_ERR_IPC_DISCONNECTED, (JSC::JSGlobalObject * globalObject, JSC::CallFrame*));
-static bool processIsExiting = false;
 
 extern "C" uint8_t Bun__getExitCode(void*);
 extern "C" uint8_t Bun__setExitCode(void*, uint8_t);
@@ -235,7 +234,7 @@ static JSValue constructProcessReleaseObject(VM& vm, JSObject* processObject)
 
 static void dispatchExitInternal(JSC::JSGlobalObject* globalObject, Process* process, int exitCode)
 {
-
+    static bool processIsExiting = false;
     if (processIsExiting)
         return;
     processIsExiting = true;
@@ -656,45 +655,51 @@ struct SignalHandleValue {
 };
 static HashMap<int, SignalHandleValue>* signalToContextIdsMap = nullptr;
 
-static const NeverDestroyed<String> signalNames[] = {
-    MAKE_STATIC_STRING_IMPL("SIGHUP"),
-    MAKE_STATIC_STRING_IMPL("SIGINT"),
-    MAKE_STATIC_STRING_IMPL("SIGQUIT"),
-    MAKE_STATIC_STRING_IMPL("SIGILL"),
-    MAKE_STATIC_STRING_IMPL("SIGTRAP"),
-    MAKE_STATIC_STRING_IMPL("SIGABRT"),
-    MAKE_STATIC_STRING_IMPL("SIGIOT"),
-    MAKE_STATIC_STRING_IMPL("SIGBUS"),
-    MAKE_STATIC_STRING_IMPL("SIGFPE"),
-    MAKE_STATIC_STRING_IMPL("SIGKILL"),
-    MAKE_STATIC_STRING_IMPL("SIGUSR1"),
-    MAKE_STATIC_STRING_IMPL("SIGSEGV"),
-    MAKE_STATIC_STRING_IMPL("SIGUSR2"),
-    MAKE_STATIC_STRING_IMPL("SIGPIPE"),
-    MAKE_STATIC_STRING_IMPL("SIGALRM"),
-    MAKE_STATIC_STRING_IMPL("SIGTERM"),
-    MAKE_STATIC_STRING_IMPL("SIGCHLD"),
-    MAKE_STATIC_STRING_IMPL("SIGCONT"),
-    MAKE_STATIC_STRING_IMPL("SIGSTOP"),
-    MAKE_STATIC_STRING_IMPL("SIGTSTP"),
-    MAKE_STATIC_STRING_IMPL("SIGTTIN"),
-    MAKE_STATIC_STRING_IMPL("SIGTTOU"),
-    MAKE_STATIC_STRING_IMPL("SIGURG"),
-    MAKE_STATIC_STRING_IMPL("SIGXCPU"),
-    MAKE_STATIC_STRING_IMPL("SIGXFSZ"),
-    MAKE_STATIC_STRING_IMPL("SIGVTALRM"),
-    MAKE_STATIC_STRING_IMPL("SIGPROF"),
-    MAKE_STATIC_STRING_IMPL("SIGWINCH"),
-    MAKE_STATIC_STRING_IMPL("SIGIO"),
-    MAKE_STATIC_STRING_IMPL("SIGINFO"),
-    MAKE_STATIC_STRING_IMPL("SIGSYS"),
-};
+static const NeverDestroyed<String>* getSignalNames()
+{
+    static const NeverDestroyed<String> signalNames[] = {
+        MAKE_STATIC_STRING_IMPL("SIGHUP"),
+        MAKE_STATIC_STRING_IMPL("SIGINT"),
+        MAKE_STATIC_STRING_IMPL("SIGQUIT"),
+        MAKE_STATIC_STRING_IMPL("SIGILL"),
+        MAKE_STATIC_STRING_IMPL("SIGTRAP"),
+        MAKE_STATIC_STRING_IMPL("SIGABRT"),
+        MAKE_STATIC_STRING_IMPL("SIGIOT"),
+        MAKE_STATIC_STRING_IMPL("SIGBUS"),
+        MAKE_STATIC_STRING_IMPL("SIGFPE"),
+        MAKE_STATIC_STRING_IMPL("SIGKILL"),
+        MAKE_STATIC_STRING_IMPL("SIGUSR1"),
+        MAKE_STATIC_STRING_IMPL("SIGSEGV"),
+        MAKE_STATIC_STRING_IMPL("SIGUSR2"),
+        MAKE_STATIC_STRING_IMPL("SIGPIPE"),
+        MAKE_STATIC_STRING_IMPL("SIGALRM"),
+        MAKE_STATIC_STRING_IMPL("SIGTERM"),
+        MAKE_STATIC_STRING_IMPL("SIGCHLD"),
+        MAKE_STATIC_STRING_IMPL("SIGCONT"),
+        MAKE_STATIC_STRING_IMPL("SIGSTOP"),
+        MAKE_STATIC_STRING_IMPL("SIGTSTP"),
+        MAKE_STATIC_STRING_IMPL("SIGTTIN"),
+        MAKE_STATIC_STRING_IMPL("SIGTTOU"),
+        MAKE_STATIC_STRING_IMPL("SIGURG"),
+        MAKE_STATIC_STRING_IMPL("SIGXCPU"),
+        MAKE_STATIC_STRING_IMPL("SIGXFSZ"),
+        MAKE_STATIC_STRING_IMPL("SIGVTALRM"),
+        MAKE_STATIC_STRING_IMPL("SIGPROF"),
+        MAKE_STATIC_STRING_IMPL("SIGWINCH"),
+        MAKE_STATIC_STRING_IMPL("SIGIO"),
+        MAKE_STATIC_STRING_IMPL("SIGINFO"),
+        MAKE_STATIC_STRING_IMPL("SIGSYS"),
+    };
+
+    return signalNames;
+}
 
 static void loadSignalNumberMap()
 {
 
     static std::once_flag signalNameToNumberMapOnceFlag;
     std::call_once(signalNameToNumberMapOnceFlag, [] {
+        auto signalNames = getSignalNames();
         signalNameToNumberMap = new HashMap<String, int>();
         signalNameToNumberMap->reserveInitialCapacity(31);
 #if OS(WINDOWS)
@@ -932,6 +937,7 @@ static void onDidChangeListeners(EventEmitter& eventEmitter, const Identifier& e
         loadSignalNumberMap();
         static std::once_flag signalNumberToNameMapOnceFlag;
         std::call_once(signalNumberToNameMapOnceFlag, [] {
+            auto signalNames = getSignalNames();
             signalNumberToNameMap = new HashMap<int, String>();
             signalNumberToNameMap->reserveInitialCapacity(31);
             signalNumberToNameMap->add(SIGHUP, signalNames[0]);
diff --git a/src/bun.js/bindings/BunString.cpp b/src/bun.js/bindings/BunString.cpp
index 36c2a99b2f3627..4d9ce102f3fb02 100644
--- a/src/bun.js/bindings/BunString.cpp
+++ b/src/bun.js/bindings/BunString.cpp
@@ -116,11 +116,9 @@ BunString toString(const char* bytes, size_t length)
 BunString fromJS(JSC::JSGlobalObject* globalObject, JSValue value)
 {
     WTF::String str = value.toWTFString(globalObject);
-
     if (UNLIKELY(str.isNull())) {
         return { BunStringTag::Dead };
     }
-
     if (UNLIKELY(str.length() == 0)) {
         return { BunStringTag::Empty };
     }
@@ -148,7 +146,10 @@ BunString toString(JSC::JSGlobalObject* globalObject, JSValue value)
 BunString toStringRef(JSC::JSGlobalObject* globalObject, JSValue value)
 {
     auto str = value.toWTFString(globalObject);
-    if (str.isEmpty()) {
+    if (UNLIKELY(str.isNull())) {
+        return { BunStringTag::Dead };
+    }
+    if (UNLIKELY(str.length() == 0)) {
         return { BunStringTag::Empty };
     }
 
diff --git a/src/bun.js/bindings/ImportMetaObject.cpp b/src/bun.js/bindings/ImportMetaObject.cpp
index c3525feb04dfaf..61b64f0229da44 100644
--- a/src/bun.js/bindings/ImportMetaObject.cpp
+++ b/src/bun.js/bindings/ImportMetaObject.cpp
@@ -80,6 +80,7 @@ static JSC::EncodedJSValue functionRequireResolve(JSC::JSGlobalObject* globalObj
 
             BunString from = Bun::toString(fromStr);
             auto result = Bun__resolveSyncWithSource(globalObject, JSC::JSValue::encode(moduleName), &from, false);
+            RETURN_IF_EXCEPTION(scope, {});
 
             if (!JSC::JSValue::decode(result).isString()) {
                 JSC::throwException(globalObject, scope, JSC::JSValue::decode(result));
@@ -260,6 +261,7 @@ extern "C" JSC::EncodedJSValue functionImportMeta__resolveSync(JSC::JSGlobalObje
     }
 
     auto result = Bun__resolveSync(globalObject, JSC::JSValue::encode(moduleName), from, isESM);
+    RETURN_IF_EXCEPTION(scope, {});
 
     if (!JSC::JSValue::decode(result).isString()) {
         JSC::throwException(globalObject, scope, JSC::JSValue::decode(result));
@@ -330,6 +332,7 @@ extern "C" JSC::EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlo
     }
 
     auto result = Bun__resolveSync(lexicalGlobalObject, JSC::JSValue::encode(moduleName), JSValue::encode(from), isESM);
+    RETURN_IF_EXCEPTION(scope, {});
 
     if (!JSC::JSValue::decode(result).isString()) {
         JSC::throwException(lexicalGlobalObject, scope, JSC::JSValue::decode(result));
@@ -426,6 +429,8 @@ JSC_DEFINE_HOST_FUNCTION(functionImportMeta__resolve,
     auto a = Bun::toString(specifier);
     auto b = Bun::toString(fromWTFString);
     auto result = JSValue::decode(Bun__resolveSyncWithStrings(globalObject, &a, &b, true));
+    RETURN_IF_EXCEPTION(scope, {});
+
     if (!result.isString()) {
         JSC::throwException(globalObject, scope, result);
         return {};
diff --git a/src/bun.js/bindings/JS2Native.cpp b/src/bun.js/bindings/JS2Native.cpp
index 4ce898bf38985a..0d93d22aff4ce2 100644
--- a/src/bun.js/bindings/JS2Native.cpp
+++ b/src/bun.js/bindings/JS2Native.cpp
@@ -32,7 +32,7 @@ JSC_DEFINE_HOST_FUNCTION(jsDollarLazy, (JSC::JSGlobalObject * lexicalGlobalObjec
         "In call to $lazy, got invalid id '%d'. This is a bug in Bun's JS2Native code generator.",
         id);
     Zig::GlobalObject* ptr = jsCast<Zig::GlobalObject*>(lexicalGlobalObject);
-    return JSValue::encode(JS2NativeGenerated::js2nativePointers[id](ptr));
+    return JSValue::encode(JS2NativeGenerated::callJS2Native(id, ptr));
 }
 
 } // namespace JS2Native
diff --git a/src/bun.js/bindings/JS2Native.h b/src/bun.js/bindings/JS2Native.h
index 6765bff3a41b0e..4fcc0745487332 100644
--- a/src/bun.js/bindings/JS2Native.h
+++ b/src/bun.js/bindings/JS2Native.h
@@ -6,8 +6,5 @@ namespace JS2Native {
 
 JSC_DECLARE_HOST_FUNCTION(jsDollarLazy);
 
-JSC_DECLARE_HOST_FUNCTION(jsDollarCpp);
-JSC_DECLARE_HOST_FUNCTION(jsDollarZig);
-
 } // namespace JS2Native
 } // namespace Bun
diff --git a/src/bun.js/bindings/JSBufferEncodingType.cpp b/src/bun.js/bindings/JSBufferEncodingType.cpp
index 3755cdf083c31b..e97504fb707072 100644
--- a/src/bun.js/bindings/JSBufferEncodingType.cpp
+++ b/src/bun.js/bindings/JSBufferEncodingType.cpp
@@ -29,20 +29,18 @@
 namespace WebCore {
 using namespace JSC;
 
-static const NeverDestroyed<String> values[] = {
-    MAKE_STATIC_STRING_IMPL("utf8"),
-    MAKE_STATIC_STRING_IMPL("ucs2"),
-    MAKE_STATIC_STRING_IMPL("utf16le"),
-    MAKE_STATIC_STRING_IMPL("latin1"),
-    MAKE_STATIC_STRING_IMPL("ascii"),
-    MAKE_STATIC_STRING_IMPL("base64"),
-    MAKE_STATIC_STRING_IMPL("base64url"),
-    MAKE_STATIC_STRING_IMPL("hex"),
-};
-
 String convertEnumerationToString(BufferEncodingType enumerationValue)
 {
-
+    static const NeverDestroyed<String> values[] = {
+        MAKE_STATIC_STRING_IMPL("utf8"),
+        MAKE_STATIC_STRING_IMPL("ucs2"),
+        MAKE_STATIC_STRING_IMPL("utf16le"),
+        MAKE_STATIC_STRING_IMPL("latin1"),
+        MAKE_STATIC_STRING_IMPL("ascii"),
+        MAKE_STATIC_STRING_IMPL("base64"),
+        MAKE_STATIC_STRING_IMPL("base64url"),
+        MAKE_STATIC_STRING_IMPL("hex"),
+    };
     ASSERT(static_cast<size_t>(enumerationValue) < std::size(values));
     return values[static_cast<size_t>(enumerationValue)];
 }
diff --git a/src/bun.js/bindings/JSPropertyIterator.zig b/src/bun.js/bindings/JSPropertyIterator.zig
index 53c1ee6af4ae96..f5361cc3ae0fe7 100644
--- a/src/bun.js/bindings/JSPropertyIterator.zig
+++ b/src/bun.js/bindings/JSPropertyIterator.zig
@@ -58,7 +58,7 @@ pub fn JSPropertyIterator(comptime options: JSPropertyIteratorOptions) type {
             var name = bun.String.dead;
             if (comptime options.include_value) {
                 const current = Bun__JSPropertyIterator__getNameAndValue(this.impl, this.globalObject, this.object, &name, i);
-                if (current.isEmpty()) {
+                if (current == .zero) {
                     return this.next();
                 }
                 current.ensureStillAlive();
diff --git a/src/bun.js/bindings/ObjectBindings.cpp b/src/bun.js/bindings/ObjectBindings.cpp
index 852bcce4f25bb8..b5e633dcfcd3ec 100644
--- a/src/bun.js/bindings/ObjectBindings.cpp
+++ b/src/bun.js/bindings/ObjectBindings.cpp
@@ -52,6 +52,8 @@ static bool getNonIndexPropertySlotPrototypePollutionMitigation(JSC::VM& vm, JSO
     return false;
 }
 
+// Returns empty for exception, returns deleted if not found.
+// Be careful when handling the return value.
 JSC::JSValue getIfPropertyExistsPrototypePollutionMitigation(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* object, const JSC::PropertyName& name)
 {
     auto scope = DECLARE_THROW_SCOPE(vm);
@@ -59,7 +61,7 @@ JSC::JSValue getIfPropertyExistsPrototypePollutionMitigation(JSC::VM& vm, JSC::J
     auto isDefined = getNonIndexPropertySlotPrototypePollutionMitigation(vm, object, globalObject, name, propertySlot);
 
     if (!isDefined) {
-        return {};
+        return JSValue::decode(JSC::JSValue::ValueDeleted);
     }
 
     scope.assertNoException();
diff --git a/src/bun.js/bindings/SQLClient.cpp b/src/bun.js/bindings/SQLClient.cpp
index 807fffffa32085..514af1b6640ab0 100644
--- a/src/bun.js/bindings/SQLClient.cpp
+++ b/src/bun.js/bindings/SQLClient.cpp
@@ -48,6 +48,7 @@ typedef union DataCellValue {
     int64_t bigint;
     uint8_t boolean;
     double date;
+    double date_with_time_zone;
     size_t bytea[2];
     WTF::StringImpl* json;
     DataCellArray array;
@@ -62,10 +63,11 @@ enum class DataCellTag : uint8_t {
     Bigint = 4,
     Boolean = 5,
     Date = 6,
-    Bytea = 7,
-    Json = 8,
-    Array = 9,
-    TypedArray = 10,
+    DateWithTimeZone = 7,
+    Bytea = 8,
+    Json = 9,
+    Array = 10,
+    TypedArray = 11,
 };
 
 typedef struct DataCell {
@@ -96,9 +98,11 @@ static JSC::JSValue toJS(JSC::VM& vm, JSC::JSGlobalObject* globalObject, DataCel
     case DataCellTag::Boolean:
         return jsBoolean(cell.value.boolean);
         break;
-    case DataCellTag::Date:
+    case DataCellTag::DateWithTimeZone:
+    case DataCellTag::Date: {
         return JSC::DateInstance::create(vm, globalObject->dateStructure(), cell.value.date);
         break;
+    }
     case DataCellTag::Bytea: {
         Zig::GlobalObject* zigGlobal = jsCast<Zig::GlobalObject*>(globalObject);
         auto* subclassStructure = zigGlobal->JSBufferSubclassStructure();
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index 8a20bebea17776..cd2d6c43baec3b 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -190,7 +190,6 @@ namespace JSCastingHelpers = JSC::JSCastingHelpers;
 constexpr size_t DEFAULT_ERROR_STACK_TRACE_LIMIT = 10;
 
 // #include <iostream>
-static bool has_loaded_jsc = false;
 
 Structure* createMemoryFootprintStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject);
 
@@ -218,6 +217,7 @@ extern "C" unsigned getJSCBytecodeCacheVersion()
 
 extern "C" void JSCInitialize(const char* envp[], size_t envc, void (*onCrash)(const char* ptr, size_t length), bool evalMode)
 {
+    static bool has_loaded_jsc = false;
     // NOLINTBEGIN
     if (has_loaded_jsc)
         return;
@@ -812,6 +812,41 @@ static void cleanupAsyncHooksData(JSC::VM& vm)
     }
 }
 
+GlobalObject* GlobalObject::create(JSC::VM& vm, JSC::Structure* structure)
+{
+    GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, &s_globalObjectMethodTable);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+GlobalObject* GlobalObject::create(JSC::VM& vm, JSC::Structure* structure, uint32_t scriptExecutionContextId)
+{
+    GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, scriptExecutionContextId, &s_globalObjectMethodTable);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+GlobalObject* GlobalObject::create(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable)
+{
+    GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, methodTable);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+GlobalObject* GlobalObject::create(JSC::VM& vm, JSC::Structure* structure, uint32_t scriptExecutionContextId, const JSC::GlobalObjectMethodTable* methodTable)
+{
+    GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, scriptExecutionContextId, methodTable);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+JSC::Structure* GlobalObject::createStructure(JSC::VM& vm)
+{
+    auto* structure = JSC::Structure::create(vm, nullptr, jsNull(), JSC::TypeInfo(JSC::GlobalObjectType, StructureFlags & ~IsImmutablePrototypeExoticObject), info());
+    structure->setTransitionWatchpointIsLikelyToBeFired(true);
+    return structure;
+}
+
 void Zig::GlobalObject::resetOnEachMicrotaskTick()
 {
     JSC::VM& vm = this->vm();
diff --git a/src/bun.js/bindings/ZigGlobalObject.h b/src/bun.js/bindings/ZigGlobalObject.h
index df8f7e4faf8ef1..57ba7dd8fcd7d3 100644
--- a/src/bun.js/bindings/ZigGlobalObject.h
+++ b/src/bun.js/bindings/ZigGlobalObject.h
@@ -100,10 +100,7 @@ class GlobalObject : public Bun::GlobalScope {
 
     static constexpr const JSC::ClassInfo* info() { return &s_info; }
 
-    static JSC::Structure* createStructure(JSC::VM& vm)
-    {
-        return JSC::Structure::create(vm, nullptr, jsNull(), JSC::TypeInfo(JSC::GlobalObjectType, StructureFlags & ~IsImmutablePrototypeExoticObject), info());
-    }
+    static JSC::Structure* createStructure(JSC::VM& vm);
 
     // Make binding code generation easier.
     GlobalObject* globalObject() { return this; }
@@ -124,33 +121,10 @@ class GlobalObject : public Bun::GlobalScope {
         return m_guardedObjects;
     }
 
-    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure)
-    {
-        GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, &s_globalObjectMethodTable);
-        ptr->finishCreation(vm);
-        return ptr;
-    }
-
-    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, uint32_t scriptExecutionContextId)
-    {
-        GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, scriptExecutionContextId, &s_globalObjectMethodTable);
-        ptr->finishCreation(vm);
-        return ptr;
-    }
-
-    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable)
-    {
-        GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, methodTable);
-        ptr->finishCreation(vm);
-        return ptr;
-    }
-
-    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, uint32_t scriptExecutionContextId, const JSC::GlobalObjectMethodTable* methodTable)
-    {
-        GlobalObject* ptr = new (NotNull, JSC::allocateCell<GlobalObject>(vm)) GlobalObject(vm, structure, scriptExecutionContextId, methodTable);
-        ptr->finishCreation(vm);
-        return ptr;
-    }
+    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure);
+    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, uint32_t scriptExecutionContextId);
+    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, const JSC::GlobalObjectMethodTable* methodTable);
+    static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure, uint32_t scriptExecutionContextId, const JSC::GlobalObjectMethodTable* methodTable);
 
     const JSDOMStructureMap& structures() const WTF_IGNORES_THREAD_SAFETY_ANALYSIS
     {
diff --git a/src/bun.js/bindings/bindings.cpp b/src/bun.js/bindings/bindings.cpp
index 51a7da1e23a37c..f80dd361480077 100644
--- a/src/bun.js/bindings/bindings.cpp
+++ b/src/bun.js/bindings/bindings.cpp
@@ -221,7 +221,8 @@ enum class AsymmetricMatcherResult : uint8_t {
     NOT_MATCHER,
 };
 
-enum class AsymmetricMatcherConstructorType : uint8_t {
+enum class AsymmetricMatcherConstructorType : int8_t {
+    exception = -1,
     none = 0,
     Symbol = 1,
     String = 2,
@@ -242,7 +243,7 @@ enum class AsymmetricMatcherConstructorType : uint8_t {
 
 extern "C" bool Expect_readFlagsAndProcessPromise(JSC__JSValue instanceValue, JSC__JSGlobalObject* globalObject, ExpectFlags* flags, JSC__JSValue* value, AsymmetricMatcherConstructorType* constructorType);
 
-extern "C" uint8_t AsymmetricMatcherConstructorType__fromJS(JSC__JSGlobalObject* globalObject, JSC__JSValue encodedValue)
+extern "C" int8_t AsymmetricMatcherConstructorType__fromJS(JSC__JSGlobalObject* globalObject, JSC__JSValue encodedValue)
 {
     JSValue value = JSValue::decode(encodedValue);
     if (value.isObject()) {
@@ -258,21 +259,21 @@ extern "C" uint8_t AsymmetricMatcherConstructorType__fromJS(JSC__JSGlobalObject*
         }
 
         auto stringConstructorValue = globalObject->stringPrototype()->getIfPropertyExists(globalObject, vm.propertyNames->constructor);
-        RETURN_IF_EXCEPTION(scope, {});
+        RETURN_IF_EXCEPTION(scope, -1);
 
         if (stringConstructorValue == object) {
             return static_cast<uint8_t>(AsymmetricMatcherConstructorType::String);
         }
 
         auto symbolConstructorValue = globalObject->symbolPrototype()->getIfPropertyExists(globalObject, vm.propertyNames->constructor);
-        RETURN_IF_EXCEPTION(scope, {});
+        RETURN_IF_EXCEPTION(scope, -1);
 
         if (symbolConstructorValue == object) {
             return static_cast<uint8_t>(AsymmetricMatcherConstructorType::Symbol);
         }
 
         auto bigIntConstructorValue = globalObject->bigIntPrototype()->getIfPropertyExists(globalObject, vm.propertyNames->constructor);
-        RETURN_IF_EXCEPTION(scope, {});
+        RETURN_IF_EXCEPTION(scope, -1);
 
         if (bigIntConstructorValue == object) {
             return static_cast<uint8_t>(AsymmetricMatcherConstructorType::BigInt);
@@ -412,6 +413,7 @@ AsymmetricMatcherResult matchAsymmetricMatcherAndGetFlags(JSGlobalObject* global
         case AsymmetricMatcherConstructorType::InstanceOf: {
             break;
         }
+        case AsymmetricMatcherConstructorType::exception:
         case AsymmetricMatcherConstructorType::none: {
             ASSERT_NOT_REACHED_WITH_MESSAGE("Invalid constructor type");
             break;
@@ -942,8 +944,10 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
         return false;
     }
 
+    case JSAsJSONType:
     case JSDOMWrapperType: {
-        if (c2Type == JSDOMWrapperType) {
+        if (c2Type == c1Type) {
+
             // https://github.com/oven-sh/bun/issues/4089
             // https://github.com/oven-sh/bun/issues/6492
             auto* url2 = jsDynamicCast<JSDOMURL*>(v2);
@@ -954,6 +958,10 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                 if ((url2 == nullptr) != (url1 == nullptr)) {
                     return false;
                 }
+            } else {
+                if ((url1 == nullptr) != (url2 == nullptr)) {
+                    goto compareAsNormalValue;
+                }
             }
 
             if (url2 && url1) {
@@ -964,8 +972,91 @@ bool Bun__deepEquals(JSC__JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                 if (url1->wrapped().href() != url2->wrapped().href()) {
                     return false;
                 }
+
+                goto compareAsNormalValue;
+            }
+
+            // TODO: FormData.
+            // It's complicated because it involves Blob.
+
+            {
+                auto urlSearchParams1 = jsDynamicCast<JSURLSearchParams*>(v1);
+                auto urlSearchParams2 = jsDynamicCast<JSURLSearchParams*>(v2);
+                if (urlSearchParams1 && urlSearchParams2) {
+                    auto& wrapped1 = urlSearchParams1->wrapped();
+                    const auto& wrapped2 = urlSearchParams2->wrapped();
+                    if (wrapped1.size() != wrapped2.size()) {
+                        return false;
+                    }
+
+                    auto iter1 = wrapped1.createIterator();
+                    while (const auto& maybePair = iter1.next()) {
+                        const auto& key = maybePair->key;
+                        const auto& value = maybePair->value;
+                        const auto& maybeValue = wrapped2.get(key);
+                        if (!maybeValue || maybeValue != value) {
+                            return false;
+                        }
+                    }
+
+                    goto compareAsNormalValue;
+                } else {
+                    if constexpr (isStrict) {
+                        // if one is a URLSearchParams and the other is not a URLSearchParams, toStrictEqual should return false.
+                        if ((urlSearchParams2 == nullptr) != (urlSearchParams1 == nullptr)) {
+                            return false;
+                        }
+                    } else {
+                        if ((urlSearchParams1 == nullptr) != (urlSearchParams2 == nullptr)) {
+                            goto compareAsNormalValue;
+                        }
+                    }
+                }
+            }
+
+            {
+                auto headers1 = jsDynamicCast<JSFetchHeaders*>(v1);
+                auto headers2 = jsDynamicCast<JSFetchHeaders*>(v2);
+                if (headers1 && headers2) {
+                    auto& wrapped1 = headers1->wrapped();
+                    const auto& wrapped2 = headers2->wrapped();
+                    if (wrapped1.size() != wrapped2.size()) {
+                        return false;
+                    }
+
+                    auto iter1 = wrapped1.createIterator();
+                    while (const auto& maybePair = iter1.next()) {
+                        const auto& key = maybePair->key;
+                        const auto& value = maybePair->value;
+                        const auto& maybeValue = wrapped2.get(key);
+                        if (maybeValue.hasException()) {
+                            return false;
+                        }
+
+                        if (maybeValue.returnValue() != value) {
+                            return false;
+                        }
+                    }
+
+                    goto compareAsNormalValue;
+                } else {
+                    if constexpr (isStrict) {
+                        // if one is a FetchHeaders and the other is not a FetchHeaders, toStrictEqual should return false.
+                        if ((headers2 == nullptr) != (headers1 == nullptr)) {
+                            return false;
+                        }
+                    } else {
+                        if ((headers1 == nullptr) != (headers2 == nullptr)) {
+                            goto compareAsNormalValue;
+                        }
+                    }
+                }
             }
         }
+
+        goto compareAsNormalValue;
+
+    compareAsNormalValue:
         break;
     }
 
@@ -2295,19 +2386,17 @@ extern "C" JSC__JSValue Bun__JSValue__call(JSContextRef ctx, JSC__JSValue object
     JSC::JSGlobalObject* globalObject = toJS(ctx);
     JSC::VM& vm = globalObject->vm();
 
-    // This is a redundant check, but we add it to make the error message clearer.
     ASSERT_WITH_MESSAGE(!vm.isCollectorBusyOnCurrentThread(), "Cannot call function inside a finalizer or while GC is running on same thread.");
 
-    if (UNLIKELY(!object))
-        return JSC::JSValue::encode(JSC::JSValue());
-
     JSC::JSValue jsObject = JSValue::decode(object);
+    ASSERT(jsObject);
+
     JSC::JSValue jsThisObject = JSValue::decode(thisObject);
 
     JSValue restoreAsyncContext;
     InternalFieldTuple* asyncContextData = nullptr;
     if (auto* wrapper = jsDynamicCast<AsyncContextFrame*>(jsObject)) {
-        jsObject = jsCast<JSC::JSObject*>(wrapper->callback.get());
+        jsObject = jsCast<JSC::JSFunction*>(wrapper->callback.get());
         asyncContextData = globalObject->m_asyncContextData.get();
         restoreAsyncContext = asyncContextData->getInternalField(0);
         asyncContextData->putInternalField(vm, 0, wrapper->context.get());
@@ -2317,10 +2406,13 @@ extern "C" JSC__JSValue Bun__JSValue__call(JSContextRef ctx, JSC__JSValue object
         jsThisObject = globalObject->globalThis();
 
     JSC::MarkedArgumentBuffer argList;
+    argList.ensureCapacity(argumentCount);
     for (size_t i = 0; i < argumentCount; i++)
         argList.append(toJS(globalObject, arguments[i]));
 
     auto callData = getCallData(jsObject);
+    ASSERT(jsObject.isCallable());
+    ASSERT(callData.type != JSC::CallData::Type::None);
     if (callData.type == JSC::CallData::Type::None)
         return JSC::JSValue::encode(JSC::JSValue());
 
@@ -3704,7 +3796,7 @@ JSC__JSValue JSC__JSValue__getIfPropertyExistsImpl(JSC__JSValue JSValue0,
     if (UNLIKELY(!object))
         return JSValue::encode({});
 
-    // Since Identifier might not ref' the string, we need to enusre it doesn't get deref'd until this function returns
+    // Since Identifier might not ref' the string, we need to ensure it doesn't get deref'd until this function returns
     const auto propertyString = String(StringImpl::createWithoutCopying({ arg1, arg2 }));
     const auto identifier = JSC::Identifier::fromString(vm, propertyString);
     const auto property = JSC::PropertyName(identifier);
@@ -4624,7 +4716,6 @@ void JSC__VM__releaseWeakRefs(JSC__VM* arg0)
     arg0->finalizeSynchronousJSExecution();
 }
 
-static auto function_string_view = MAKE_STATIC_STRING_IMPL("Function");
 void JSC__JSValue__getClassName(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, ZigString* arg2)
 {
     JSValue value = JSValue::decode(JSValue0);
@@ -4638,7 +4729,7 @@ void JSC__JSValue__getClassName(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1
     auto view = WTF::StringView(std::span { ptr, strlen(ptr) });
 
     // Fallback to .name if className is empty
-    if (view.length() == 0 || StringView(String(function_string_view)) == view) {
+    if (view.length() == 0 || StringView("Function"_s) == view) {
         JSC__JSValue__getNameProperty(JSValue0, arg1, arg2);
         return;
     }
@@ -5079,7 +5170,7 @@ JSC__JSValue JSC__JSValue__fastGetDirect_(JSC__JSValue JSValue0, JSC__JSGlobalOb
     return JSValue::encode(value.getObject()->getDirect(globalObject->vm(), PropertyName(builtinNameMap(globalObject->vm(), arg2))));
 }
 
-JSC__JSValue JSC__JSValue__fastGet_(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, unsigned char arg2)
+JSC__JSValue JSC__JSValue__fastGet(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, unsigned char arg2)
 {
     JSC::JSValue value = JSC::JSValue::decode(JSValue0);
     ASSERT(value.isCell());
@@ -5628,7 +5719,37 @@ CPP_DECL double JSC__JSValue__getUnixTimestamp(JSC__JSValue timeValue)
     if (!date)
         return PNaN;
 
-    return date->internalNumber();
+    double number = date->internalNumber();
+
+    return number;
+}
+
+extern "C" JSC::EncodedJSValue JSC__JSValue__getOwnByValue(JSC__JSValue value, JSC__JSGlobalObject* globalObject, JSC__JSValue propertyValue)
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSC::JSObject* object = JSValue::decode(value).getObject();
+    JSC::JSValue property = JSValue::decode(propertyValue);
+    uint32_t index;
+
+    PropertySlot slot(object, PropertySlot::InternalMethodType::GetOwnProperty);
+    if (property.getUInt32(index)) {
+        if (!object->getOwnPropertySlotByIndex(object, globalObject, index, slot))
+            return JSC::JSValue::encode({});
+
+        RETURN_IF_EXCEPTION(scope, {});
+
+        return JSC::JSValue::encode(slot.getValue(globalObject, index));
+    } else {
+        auto propertyName = property.toPropertyKey(globalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        if (!object->getOwnNonIndexPropertySlot(vm, object->structure(), propertyName, slot))
+            return JSC::JSValue::encode({});
+
+        RETURN_IF_EXCEPTION(scope, {});
+
+        return JSC::JSValue::encode(slot.getValue(globalObject, propertyName));
+    }
 }
 
 extern "C" double Bun__parseDate(JSC::JSGlobalObject* globalObject, BunString* str)
@@ -5637,6 +5758,13 @@ extern "C" double Bun__parseDate(JSC::JSGlobalObject* globalObject, BunString* s
     return vm.dateCache.parseDate(globalObject, vm, str->toWTFString());
 }
 
+extern "C" EncodedJSValue JSC__JSValue__dateInstanceFromNumber(JSC::JSGlobalObject* globalObject, double unixTimestamp)
+{
+    auto& vm = globalObject->vm();
+    JSC::DateInstance* date = JSC::DateInstance::create(vm, globalObject->dateStructure(), unixTimestamp);
+    return JSValue::encode(date);
+}
+
 extern "C" EncodedJSValue JSC__JSValue__dateInstanceFromNullTerminatedString(JSC::JSGlobalObject* globalObject, const LChar* nullTerminatedChars)
 {
     double dateSeconds = WTF::parseDate(std::span<const LChar>(nullTerminatedChars, strlen(reinterpret_cast<const char*>(nullTerminatedChars))));
@@ -5887,3 +6015,12 @@ CPP_DECL void JSC__SourceProvider__deref(JSC::SourceProvider* provider)
 {
     provider->deref();
 }
+
+CPP_DECL bool Bun__CallFrame__isFromBunMain(JSC::CallFrame* callFrame, JSC::VM* vm)
+{
+    auto source = callFrame->callerSourceOrigin(*vm);
+
+    if (source.isNull())
+        return false;
+    return source.string() == "builtin://bun/main"_s;
+}
diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 17bea2308362f2..758c7c5ddeb3d5 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -26,42 +26,31 @@ const OOM = bun.OOM;
 
 pub const JSObject = extern struct {
     pub const shim = Shimmer("JSC", "JSObject", @This());
-    bytes: shim.Bytes,
     const cppFn = shim.cppFn;
-    pub const include = "JavaScriptCore/JSObject.h";
-    pub const name = "JSC::JSObject";
-    pub const namespace = "JSC";
 
-    pub fn getArrayLength(this: *JSObject) usize {
-        return cppFn("getArrayLength", .{
-            this,
-        });
+    pub fn toJS(obj: *JSObject) JSValue {
+        return JSValue.fromCell(obj);
     }
 
-    const InitializeCallback = *const fn (ctx: *anyopaque, obj: *JSObject, global: *JSGlobalObject) callconv(.C) void;
-    extern fn JSC__JSObject__create(global_object: *JSGlobalObject, length: usize, ctx: *anyopaque, initializer: InitializeCallback) JSValue;
-    pub fn create(global_object: *JSGlobalObject, length: usize, ctx: *anyopaque, initializer: InitializeCallback) JSValue {
-        return JSC__JSObject__create(global_object, length, ctx, initializer);
+    pub inline fn put(obj: *JSObject, global: *JSGlobalObject, key: anytype, value: JSValue) !void {
+        obj.toJS().put(global, key, value);
+    }
+
+    pub inline fn putAllFromStruct(obj: *JSObject, global: *JSGlobalObject, properties: anytype) !void {
+        inline for (comptime std.meta.fieldNames(@TypeOf(properties))) |field| {
+            try obj.put(global, field, @field(properties, field));
+        }
     }
 
     extern fn JSC__createStructure(*JSC.JSGlobalObject, *JSC.JSCell, u32, names: [*]bun.String) JSC.JSValue;
-    extern fn JSC__createEmptyObjectWithStructure(*JSC.JSGlobalObject, *anyopaque) JSC.JSValue;
-    extern fn JSC__putDirectOffset(*JSC.VM, JSC.JSValue, offset: u32, JSC.JSValue) void;
 
     pub fn createStructure(global: *JSGlobalObject, owner: JSC.JSValue, length: u32, names: [*]bun.String) JSValue {
         JSC.markBinding(@src());
         return JSC__createStructure(global, owner.asCell(), length, names);
     }
 
-    pub fn uninitialized(global: *JSGlobalObject, structure: JSC.JSValue) JSValue {
-        JSC.markBinding(@src());
-        return JSC__createEmptyObjectWithStructure(global, structure.asCell());
-    }
-
-    pub fn putDirectOffset(this: JSValue, vm: *VM, offset: u32, value: JSValue) void {
-        JSC.markBinding(@src());
-        return JSC__putDirectOffset(vm, this, offset, value);
-    }
+    const InitializeCallback = *const fn (ctx: *anyopaque, obj: *JSObject, global: *JSGlobalObject) callconv(.C) void;
+    extern fn JSC__JSObject__create(global_object: *JSGlobalObject, length: usize, ctx: *anyopaque, initializer: InitializeCallback) JSValue;
 
     pub fn Initializer(comptime Ctx: type, comptime func: fn (*Ctx, obj: *JSObject, global: *JSGlobalObject) void) type {
         return struct {
@@ -73,7 +62,7 @@ pub const JSObject = extern struct {
 
     pub fn createWithInitializer(comptime Ctx: type, creator: *Ctx, global: *JSGlobalObject, length: usize) JSValue {
         const Type = Initializer(Ctx, Ctx.create);
-        return create(global, length, creator, Type.call);
+        return JSC__JSObject__create(global, length, creator, Type.call);
     }
 
     pub fn getIndex(this: JSValue, globalThis: *JSGlobalObject, i: u32) JSValue {
@@ -84,25 +73,9 @@ pub const JSObject = extern struct {
         });
     }
 
-    pub fn putRecord(this: *JSObject, global: *JSGlobalObject, key: *ZigString, values: [*]ZigString, values_len: usize) void {
-        return cppFn("putRecord", .{ this, global, key, values, values_len });
-    }
-
-    pub fn getDirect(this: *JSObject, globalThis: *JSGlobalObject, str: *const ZigString) JSValue {
-        return cppFn("getDirect", .{
-            this,
-            globalThis,
-            str,
-        });
+    pub fn putRecord(this: *JSObject, global: *JSGlobalObject, key: *ZigString, values: []ZigString) void {
+        return cppFn("putRecord", .{ this, global, key, values.ptr, values.len });
     }
-
-    pub const Extern = [_][]const u8{
-        "putRecord",
-        "getArrayLength",
-        "getIndex",
-        "putAtIndex",
-        "getDirect",
-    };
 };
 
 pub const CachedBytecode = opaque {
@@ -1127,9 +1100,7 @@ pub const DOMFormData = opaque {
         DOMFormData__toQueryString(this, ctx, &Wrapper.run);
     }
 
-    pub fn fromJS(
-        value: JSValue,
-    ) ?*DOMFormData {
+    pub fn fromJS(value: JSValue) ?*DOMFormData {
         return shim.cppFn("fromJS", .{
             value,
         });
@@ -2434,7 +2405,7 @@ pub const JSPromise = extern struct {
     }
 
     pub fn wrapValue(globalObject: *JSGlobalObject, value: JSValue) JSValue {
-        if (value.isEmpty()) {
+        if (value == .zero) {
             return resolvedPromiseValue(globalObject, JSValue.jsUndefined());
         } else if (value.isEmptyOrUndefinedOrNull() or !value.isCell()) {
             return resolvedPromiseValue(globalObject, value);
@@ -2938,7 +2909,7 @@ pub const JSFunction = extern struct {
     pub fn create(
         global: *JSGlobalObject,
         fn_name: anytype,
-        comptime implementation: JSHostFunctionType,
+        comptime implementation: JSHostZigFunction,
         function_length: u32,
         options: CreateJSFunctionOptions,
     ) JSValue {
@@ -2948,7 +2919,7 @@ pub const JSFunction = extern struct {
                 bun.String => fn_name,
                 else => bun.String.init(fn_name),
             },
-            implementation,
+            toJSHostFunction(implementation),
             function_length,
             options.implementation_visibility,
             options.intrinsic,
@@ -3005,9 +2976,10 @@ pub const JSGlobalObject = opaque {
     }
 
     pub inline fn toJSValue(globalThis: *JSGlobalObject) JSValue {
-        return @enumFromInt(@as(JSValue.Type, @bitCast(@intFromPtr(globalThis))));
+        return @enumFromInt(@intFromPtr(globalThis));
     }
 
+    /// Deprecated: use `throwInvalidArguments2`
     pub fn throwInvalidArguments(
         this: *JSGlobalObject,
         comptime fmt: [:0]const u8,
@@ -3017,6 +2989,16 @@ pub const JSGlobalObject = opaque {
         this.vm().throwError(this, err);
     }
 
+    /// New system for throwing errors: returning bun.JSError
+    pub fn throwInvalidArguments2(
+        this: *JSGlobalObject,
+        comptime fmt: [:0]const u8,
+        args: anytype,
+    ) bun.JSError {
+        const err = JSC.toInvalidArguments(fmt, args, this);
+        return this.vm().throwError2(this, err);
+    }
+
     pub inline fn throwMissingArgumentsValue(this: *JSGlobalObject, comptime arg_names: []const []const u8) JSValue {
         switch (arg_names.len) {
             0 => @compileError("requires at least one argument"),
@@ -3028,6 +3010,110 @@ pub const JSGlobalObject = opaque {
         return .zero;
     }
 
+    /// Pass a JSOrMemoryError!JSValue and variants through the C ABI boundary
+    ///
+    /// In C++, WebKit represents a thrown JavaScript expression as
+    /// JSValue.zero/nullptr, and stores the actual exception on the global. In
+    /// Zig, we represent this zero as a distinct Zig error type
+    /// 'error.JSError'. Instead of using JSValue.zero directly, we pass the
+    /// Zig error to this function as "proof" there is an error. In debug, this
+    /// will also assert that an error is actually present.
+    ///
+    /// If .zero is exposed to JS, it will be considered a JSCell but with a
+    /// null pointer and will segfault via null-pointer dereference.
+    ///
+    /// Ideally, we can use this function as little as possible, and instead
+    /// have auto-generated wrappers that do this conversion. It is ugly to use
+    /// on purpose.
+    pub inline fn errorUnionToCPP(global: *JSGlobalObject, result: anytype) RemoveError(@TypeOf(result)) {
+        const T = @TypeOf(result);
+
+        const unwrapped = switch (@typeInfo(T)) {
+            .ErrorUnion => result catch |err| {
+                bun.handleErrorReturnTrace(err, @errorReturnTrace());
+                return global.errorSetToCPP(err, T);
+            },
+            .ErrorSet => return global.errorSetToCPP(result, T),
+            else => result,
+        };
+
+        // Validate exception state aligns with return value.
+        // Currently only enabled for JSValue.
+        const Return = RemoveError(T);
+        if (bun.Environment.isDebug and Return == JSValue) {
+            const null_value: Return = comptime if (Return == JSC.JSValue)
+                .zero
+            else
+                null;
+
+            if (unwrapped == null_value) {
+                std.debug.assert(global.hasException()); // Exception was cleared, yet returned.
+            } else if (Return == JSC.JSValue and unwrapped == .undefined) {
+                // TODO: a lot of our code returns undefined when it throws an error.
+            } else {
+                if (global.tryTakeException()) |exception| {
+                    bun.Output.err("assertion failure", "Pending exception while returning non-empty JSValue", .{});
+                    bun.Output.printErrorln("Exception thrown:", .{});
+                    bun.Output.flush();
+                    global.bunVM().printErrorLikeObjectToConsole(exception);
+                    bun.Output.printErrorln("Value returned:", .{});
+                    bun.Output.flush();
+                    if (Return == JSValue) {
+                        unwrapped.print(global, .Log, .Error);
+                    } else {
+                        bun.Output.printErrorln("  {any}", .{unwrapped});
+                    }
+                    bun.Output.flush();
+                    @panic("Pending exception while returning non-empty JSValue");
+                }
+            }
+        }
+
+        return unwrapped;
+    }
+
+    pub fn RemoveError(T: type) type {
+        return switch (@typeInfo(T)) {
+            .ErrorSet => bun.JSC.JSValue,
+            .ErrorUnion => |eu| if (@typeInfo(eu.payload) == .Pointer)
+                ?eu.payload
+            else
+                eu.payload,
+            else => T,
+        };
+    }
+
+    inline fn errorSetToCPP(global: *JSGlobalObject, err: anytype, T: type) RemoveError(T) {
+        const info = @typeInfo(@TypeOf(err));
+        comptime bun.assert(info == .ErrorSet);
+        const Return = RemoveError(T);
+        const null_value: Return = comptime if (Return == JSC.JSValue)
+            .zero
+        else
+            null;
+
+        const possible_errors = comptime parseErrorSet(
+            T,
+            info.ErrorSet orelse
+                @compileError("host function cannot return 'anyerror!JSValue'"),
+        );
+
+        if (possible_errors.OutOfMemory and err == error.OutOfMemory) {
+            bun.assert(!global.hasException()); // dual exception
+            global.throwOutOfMemory();
+            return null_value;
+        }
+
+        if (possible_errors.JSError and err == error.JSError) {
+            bun.assert(global.hasException()); // Exception was cleared, yet returned.
+            return null_value;
+        }
+
+        // all errors have now been handled. parseErrorSet will report
+        // a compile error if there is another possible error
+        unreachable;
+    }
+
     pub fn createInvalidArgumentType(
         this: *JSGlobalObject,
         comptime name_: []const u8,
@@ -3061,6 +3147,7 @@ pub const JSGlobalObject = opaque {
         this.ERR_INVALID_ARG_TYPE("The \"{s}\" argument must be of type {s}. Received {}", .{ argname, typename, bun.fmt.quote(ty_str.slice()) }).throw();
         return .zero;
     }
+
     pub fn throwInvalidArgumentRangeValue(
         this: *JSGlobalObject,
         argname: []const u8,
@@ -3097,8 +3184,8 @@ pub const JSGlobalObject = opaque {
         comptime name_: []const u8,
         comptime expected: usize,
         got: usize,
-    ) void {
-        this.throwValue(this.createNotEnoughArguments(name_, expected, got));
+    ) bun.JSError {
+        return this.throwValue2(this.createNotEnoughArguments(name_, expected, got));
     }
 
     extern fn JSC__JSGlobalObject__reload(JSC__JSGlobalObject__ptr: *JSGlobalObject) void;
@@ -3236,6 +3323,16 @@ pub const JSGlobalObject = opaque {
             this.vm().throwError(this, instance);
     }
 
+    pub fn throw2(
+        this: *JSGlobalObject,
+        comptime fmt: [:0]const u8,
+        args: anytype,
+    ) JSError {
+        const instance = this.createErrorInstance(fmt, args);
+        bun.assert(instance != .zero);
+        return this.vm().throwError2(this, instance);
+    }
+
     pub fn throwPretty(
         this: *JSGlobalObject,
         comptime fmt: [:0]const u8,
@@ -3295,13 +3392,11 @@ pub const JSGlobalObject = opaque {
         this.vm().throwError(this, value);
     }
 
-    // eventually merge this with throwValue, but that's a big diff
-    pub fn throwValueRet(
+    pub fn throwValue2(
         this: *JSGlobalObject,
         value: JSC.JSValue,
-    ) JSValue {
-        this.vm().throwError(this, value);
-        return .zero;
+    ) JSError {
+        return this.vm().throwError2(this, value);
     }
 
     pub fn throwError(
@@ -3330,10 +3425,6 @@ pub const JSGlobalObject = opaque {
     }
     pub const ctx = ref;
 
-    pub inline fn ptr(this: *JSGlobalObject) *JSGlobalObject {
-        return this;
-    }
-
     extern fn JSC__JSGlobalObject__createAggregateError(*JSGlobalObject, [*]const JSValue, usize, *const ZigString) JSValue;
     pub fn createAggregateError(globalObject: *JSGlobalObject, errors: []const JSValue, message: *const ZigString) JSValue {
         return JSC__JSGlobalObject__createAggregateError(globalObject, errors.ptr, errors.len, message);
@@ -3357,14 +3448,11 @@ pub const JSGlobalObject = opaque {
     pub fn takeException(this: *JSGlobalObject, proof: bun.JSError) JSValue {
         switch (proof) {
             error.JSError => {},
+            error.OutOfMemory => this.throwOutOfMemory(),
         }
 
-        if (bun.Environment.allow_assert)
-            bun.assert(this.hasException());
-
         return this.tryTakeException() orelse {
-            bun.assert(false);
-            return .zero;
+            @panic("A JavaScript exception was thrown, however it was cleared before it could be read.");
         };
     }
 
@@ -3556,6 +3644,27 @@ pub const JSGlobalObject = opaque {
         return default;
     }
 
+    pub inline fn createObjectFromStruct(global: *JSGlobalObject, properties: anytype) *JSObject {
+        const obj = JSValue.createEmptyObject(global, comptime std.meta.fields(@TypeOf(properties)).len).uncheckedPtrCast(JSObject);
+        obj.putAllFromStruct(global, properties) catch {
+            // empty object has no setters. this must be a low-allocation OOM,
+            // wherethrowing will be nearly impossible to handle correctly.
+            bun.outOfMemory();
+        };
+        return obj;
+    }
+
+    pub inline fn createHostFunction(
+        global: *JSGlobalObject,
+        comptime display_name: [:0]const u8,
+        // when querying from JavaScript, 'func.name'
+        comptime function: anytype,
+        // when querying from JavaScript, 'func.len'
+        comptime argument_count: u32,
+    ) JSValue {
+        return NewRuntimeFunction(global, ZigString.static(display_name), argument_count, toJSHostFunction(function), false, false);
+    }
+
     pub usingnamespace @import("ErrorCode").JSGlobalObjectExtensions;
 
     extern fn JSC__JSGlobalObject__bunVM(*JSGlobalObject) *VM;
@@ -3569,7 +3678,7 @@ pub const JSGlobalObject = opaque {
     extern fn JSGlobalObject__throwTerminationException(this: *JSGlobalObject) void;
 };
 
-pub const JSNativeFn = JSHostFunctionPtr;
+pub const JSNativeFn = JSHostZigFunction;
 
 pub const JSArrayIterator = struct {
     i: u32 = 0,
@@ -3585,6 +3694,7 @@ pub const JSArrayIterator = struct {
         };
     }
 
+    // TODO: this can throw
     pub fn next(this: *JSArrayIterator) ?JSValue {
         if (!(this.i < this.len)) {
             return null;
@@ -3649,9 +3759,12 @@ pub const JSMap = opaque {
     };
 };
 
+// TODO: this should not need to be `pub`
 pub const JSValueReprInt = i64;
 
-pub const JSValue = enum(JSValueReprInt) {
+/// ABI-compatible with EncodedJSValue
+/// In the future, this type will exclude `zero`, encoding it as `error.JSError` instead.
+pub const JSValue = enum(i64) {
     zero = 0,
     undefined = 0xa,
     null = 0x2,
@@ -3659,7 +3772,22 @@ pub const JSValue = enum(JSValueReprInt) {
     false = 0x6,
     _,
 
-    pub const Type = JSValueReprInt;
+    /// When JavaScriptCore throws something, it returns a null cell (0). The
+    /// exception is set on the global object. ABI-compatible with EncodedJSValue.
+    pub const MaybeException = enum(i64) {
+        zero = 0,
+        _,
+
+        pub fn unwrap(val: JSValue.MaybeException) JSError!JSValue {
+            return if (val != .zero) @enumFromInt(@intFromEnum(val)) else JSError.JSError;
+        }
+    };
+
+    /// This function is a migration stepping stone to JSError
+    /// Prefer annotating the type as `JSValue.MaybeException`
+    pub fn unwrapZeroToJSError(val: JSValue) JSError!JSValue {
+        return if (val != .zero) val else JSError.JSError;
+    }
 
     pub const shim = Shimmer("JSC", "JSValue", @This());
     pub const is_pointer = false;
@@ -4141,7 +4269,7 @@ pub const JSValue = enum(JSValueReprInt) {
         thisObject: JSValue,
         argumentCount: usize,
         arguments: [*]const JSValue,
-    ) JSValue;
+    ) JSValue.MaybeException;
 
     pub fn call(function: JSValue, global: *JSGlobalObject, thisValue: JSC.JSValue, args: []const JSC.JSValue) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
@@ -4152,26 +4280,23 @@ pub const JSValue = enum(JSValueReprInt) {
                 loop.debug.last_fn_name.deref();
                 loop.debug.last_fn_name = function.getName(global);
             }
+            bun.assert(function.isCallable(global.vm()));
         }
 
-        const value = Bun__JSValue__call(
+        return Bun__JSValue__call(
             global,
             function,
             thisValue,
             args.len,
             args.ptr,
-        );
-        if (value == .zero) return error.JSError;
-        return value;
+        ).unwrap();
     }
 
     /// The value cannot be empty. Check `!this.isEmpty()` before calling this function
     pub fn jsType(
         this: JSValue,
     ) JSType {
-        if (comptime bun.Environment.allow_assert) {
-            bun.assert(!this.isEmpty());
-        }
+        bun.assert(this != .zero);
         return cppFn("jsType", .{this});
     }
 
@@ -4327,6 +4452,12 @@ pub const JSValue = enum(JSValueReprInt) {
         return JSC__JSValue__dateInstanceFromNullTerminatedString(globalObject, str);
     }
 
+    extern fn JSC__JSValue__dateInstanceFromNumber(*JSGlobalObject, f64) JSValue;
+    pub fn fromDateNumber(globalObject: *JSGlobalObject, value: f64) JSValue {
+        JSC.markBinding(@src());
+        return JSC__JSValue__dateInstanceFromNumber(globalObject, value);
+    }
+
     extern fn JSBuffer__isBuffer(*JSGlobalObject, JSValue) bool;
     pub fn isBuffer(value: JSValue, global: *JSGlobalObject) bool {
         JSC.markBinding(@src());
@@ -4787,13 +4918,6 @@ pub const JSValue = enum(JSValueReprInt) {
             else => false,
         };
     }
-    /// Empty as in "JSValue {}" rather than an empty string
-    pub inline fn isEmpty(this: JSValue) bool {
-        return switch (@intFromEnum(this)) {
-            0 => true,
-            else => false,
-        };
-    }
     pub fn isBoolean(this: JSValue) bool {
         return cppFn("isBoolean", .{this});
     }
@@ -4989,13 +5113,17 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("toZigString", .{ this, out, global });
     }
 
-    /// Increments the reference count
-    ///
-    /// **You must call `.deref()` or it will leak memory**
+    /// Increments the reference count, you must call `.deref()` or it will leak memory.
+    /// Returns String.Dead on error. Deprecated in favor of `toBunString2`
     pub fn toBunString(this: JSValue, globalObject: *JSC.JSGlobalObject) bun.String {
         return bun.String.fromJS(this, globalObject);
     }
 
+    /// Increments the reference count, you must call `.deref()` or it will leak memory.
+    pub fn toBunString2(this: JSValue, globalObject: *JSC.JSGlobalObject) JSError!bun.String {
+        return bun.String.fromJS2(this, globalObject);
+    }
+
     /// this: RegExp value
     /// other: string value
     pub fn toMatch(this: JSValue, global: *JSGlobalObject, other: JSValue) bool {
@@ -5048,6 +5176,7 @@ pub const JSValue = enum(JSValueReprInt) {
         });
     }
 
+    /// Deprecated: replace with 'toBunString2'
     pub inline fn getZigString(this: JSValue, global: *JSGlobalObject) ZigString {
         var str = ZigString.init("");
         this.toZigString(&str, global);
@@ -5072,6 +5201,19 @@ pub const JSValue = enum(JSValueReprInt) {
         return str.toUTF8(allocator);
     }
 
+    /// Convert a JSValue to a string, potentially calling `toString` on the
+    /// JSValue in JavaScript. Can throw an error.
+    pub fn toSlice2(this: JSValue, global: *JSGlobalObject, allocator: std.mem.Allocator) JSError!ZigString.Slice {
+        const str = try bun.String.fromJS2(this, global);
+        defer str.deref();
+
+        // This keeps the WTF::StringImpl alive if it was originally a latin1
+        // ASCII-only string.
+        //
+        // Otherwise, it will be cloned using the allocator.
+        return str.toUTF8(allocator);
+    }
+
     pub inline fn toSliceZ(this: JSValue, global: *JSGlobalObject, allocator: std.mem.Allocator) ZigString.Slice {
         return getZigString(this, global).toSliceZ(allocator);
     }
@@ -5176,6 +5318,10 @@ pub const JSValue = enum(JSValueReprInt) {
         pub fn has(property: []const u8) bool {
             return bun.ComptimeEnumMap(BuiltinName).has(property);
         }
+
+        pub fn get(property: []const u8) ?BuiltinName {
+            return bun.ComptimeEnumMap(BuiltinName).get(property);
+        }
     };
 
     pub fn fastGetOrElse(this: JSValue, global: *JSGlobalObject, builtin_name: BuiltinName, alternate: ?JSC.JSValue) ?JSValue {
@@ -5191,7 +5337,7 @@ pub const JSValue = enum(JSValueReprInt) {
     pub fn fastGet(this: JSValue, global: *JSGlobalObject, builtin_name: BuiltinName) ?JSValue {
         if (bun.Environment.allow_assert)
             bun.assert(this.isObject());
-        const result = fastGet_(this, global, @intFromEnum(builtin_name));
+        const result = JSC__JSValue__fastGet(this, global, @intFromEnum(builtin_name)).legacyUnwrap();
         if (result == .zero or
             // JS APIs treat {}.a as mostly the same as though it was not defined
             result == .undefined)
@@ -5211,10 +5357,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return result;
     }
 
-    pub fn fastGet_(this: JSValue, global: *JSGlobalObject, builtin_name: u8) JSValue {
-        return cppFn("fastGet_", .{ this, global, builtin_name });
-    }
-
+    extern fn JSC__JSValue__fastGet(value: JSValue, global: *JSGlobalObject, builtin_id: u8) GetResult;
     extern fn JSC__JSValue__fastGetOwn(value: JSValue, globalObject: *JSGlobalObject, property: BuiltinName) JSValue;
     pub fn fastGetOwn(this: JSValue, global: *JSGlobalObject, builtin_name: BuiltinName) ?JSValue {
         const result = JSC__JSValue__fastGetOwn(this, global, builtin_name);
@@ -5229,10 +5372,42 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("fastGetDirect_", .{ this, global, builtin_name });
     }
 
-    /// Do not use this directly! Use `get` instead.
-    pub fn getIfPropertyExistsImpl(this: JSValue, global: *JSGlobalObject, ptr: [*]const u8, len: u32) JSValue {
-        return cppFn("getIfPropertyExistsImpl", .{ this, global, ptr, len });
-    }
+    /// Problem: The `get` needs to model !?JSValue
+    /// - null  -> the property does not exist
+    /// - error -> the get operation threw
+    /// - any other JSValue -> success. this could be jsNull() or jsUndefined()
+    ///
+    /// `.zero` is already used for the error state
+    ///
+    /// Deleted is a special encoding used in JSC hash map internals used for
+    /// the null state. It is re-used here for encoding the "not present" state.
+    const GetResult = enum(i64) {
+        thrown_exception = 0,
+        does_not_exist = 0x4, // JSC::JSValue::ValueDeleted
+        _,
+
+        fn legacyUnwrap(value: GetResult) ?JSValue {
+            return switch (value) {
+                // footgun! caller must check hasException on every `get` or else Bun will crash
+                .thrown_exception => null,
+
+                .does_not_exist => null,
+                else => @enumFromInt(@intFromEnum(value)),
+            };
+        }
+
+        fn unwrap(value: GetResult, global: *JSGlobalObject) JSError!?JSValue {
+            return switch (value) {
+                .thrown_exception => {
+                    bun.assert(global.hasException());
+                    return error.JSError;
+                },
+                .does_not_exist => null,
+                else => @enumFromInt(@intFromEnum(value)),
+            };
+        }
+    };
+    extern fn JSC__JSValue__getIfPropertyExistsImpl(target: JSValue, global: *JSGlobalObject, ptr: [*]const u8, len: u32) GetResult;
 
     pub fn getIfPropertyExistsFromPath(this: JSValue, global: *JSGlobalObject, path: JSValue) JSValue {
         return cppFn("getIfPropertyExistsFromPath", .{ this, global, path });
@@ -5251,6 +5426,10 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     pub fn _then(this: JSValue, global: *JSGlobalObject, ctx: JSValue, resolve: JSNativeFn, reject: JSNativeFn) void {
+        return cppFn("_then", .{ this, global, ctx, toJSHostFunction(resolve), toJSHostFunction(reject) });
+    }
+
+    pub fn _then2(this: JSValue, global: *JSGlobalObject, ctx: JSValue, resolve: JSHostFunctionType, reject: JSHostFunctionType) void {
         return cppFn("_then", .{ this, global, ctx, resolve, reject });
     }
 
@@ -5268,6 +5447,8 @@ pub const JSValue = enum(JSValueReprInt) {
 
     /// Equivalent to `obj.property` in JavaScript.
     /// Reminder: `undefined` is a value!
+    ///
+    /// Prefer `get2` in new code, as this function is incapable of returning an exception
     pub fn get(this: JSValue, global: *JSGlobalObject, property: []const u8) ?JSValue {
         if (comptime bun.Environment.isDebug) {
             if (BuiltinName.has(property)) {
@@ -5275,11 +5456,44 @@ pub const JSValue = enum(JSValueReprInt) {
             }
         }
 
-        const value = getIfPropertyExistsImpl(this, global, property.ptr, @as(u32, @intCast(property.len)));
-        return if (value.isEmpty()) null else value;
+        return JSC__JSValue__getIfPropertyExistsImpl(
+            this,
+            global,
+            property.ptr,
+            @intCast(property.len),
+        ).legacyUnwrap();
+    }
+
+    /// Equivalent to `target[property]`. Calls userland getters/proxies.  Can
+    /// throw. Null indicates the property does not exist. JavaScript undefined
+    /// can exist as a property and is different than null.
+    ///
+    /// `property` must be either `[]const u8`. A comptime slice may defer to
+    /// calling `fastGet`, which use a more optimal code path. This function is
+    /// marked `inline` to allow Zig to determine if `fastGet` should be used
+    /// per invocation.
+    ///
+    /// This function will eventually replace `get`.
+    pub inline fn get2(target: JSValue, global: *JSGlobalObject, property: anytype) JSError!?JSValue {
+        if (bun.Environment.allow_assert) bun.assert(target.isObject());
+        const property_slice: []const u8 = property; // must be a slice!
+
+        // This call requires `get2` to be `inline`
+        if (bun.isComptimeKnown(property_slice)) {
+            if (comptime BuiltinName.get(property_slice)) |builtin| {
+                return target.fastGet(global, builtin);
+            }
+        }
+
+        return JSC__JSValue__getIfPropertyExistsImpl(
+            target,
+            global,
+            property_slice.ptr,
+            @intCast(property_slice.len),
+        ).unwrap(global);
     }
 
-    extern fn JSC__JSValue__getOwn(value: JSValue, globalObject: *JSGlobalObject, propertyName: [*c]const bun.String) JSValue;
+    extern fn JSC__JSValue__getOwn(value: JSValue, globalObject: *JSGlobalObject, propertyName: *const bun.String) JSValue;
 
     /// Get *own* property value (i.e. does not resolve property in the prototype chain)
     pub fn getOwn(this: JSValue, global: *JSGlobalObject, property_name: anytype) ?JSValue {
@@ -5288,6 +5502,13 @@ pub const JSValue = enum(JSValueReprInt) {
         return if (@intFromEnum(value) != 0) value else return null;
     }
 
+    extern fn JSC__JSValue__getOwnByValue(value: JSValue, globalObject: *JSGlobalObject, propertyValue: JSValue) JSValue;
+
+    pub fn getOwnByValue(this: JSValue, global: *JSGlobalObject, property_value: JSValue) ?JSValue {
+        const value = JSC__JSValue__getOwnByValue(this, global, property_value);
+        return if (@intFromEnum(value) != 0) value else return null;
+    }
+
     pub fn getOwnTruthy(this: JSValue, global: *JSGlobalObject, property_name: anytype) ?JSValue {
         if (getOwn(this, global, property_name)) |prop| {
             if (prop == .undefined) return null;
@@ -5297,7 +5518,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return null;
     }
 
-    /// safe to use on any JSValue
+    /// Safe to use on any JSValue
     pub fn implementsToString(this: JSValue, global: *JSGlobalObject) bool {
         if (!this.isObject())
             return false;
@@ -5306,6 +5527,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return function.isCell() and function.isCallable(global.vm());
     }
 
+    // TODO: replace calls to this function with `getOptional`
     pub fn getOwnTruthyComptime(this: JSValue, global: *JSGlobalObject, comptime property: []const u8) ?JSValue {
         if (comptime bun.ComptimeEnumMap(BuiltinName).has(property)) {
             return fastGetOwn(this, global, @field(BuiltinName, property));
@@ -5314,7 +5536,8 @@ pub const JSValue = enum(JSValueReprInt) {
         return getOwnTruthy(this, global, property);
     }
 
-    pub fn getTruthyComptime(this: JSValue, global: *JSGlobalObject, comptime property: []const u8) ?JSValue {
+    // TODO: replace calls to this function with `getOptional`
+    pub fn getTruthyComptime(this: JSValue, global: *JSGlobalObject, comptime property: []const u8) bun.JSError!?JSValue {
         if (comptime bun.ComptimeEnumMap(BuiltinName).has(property)) {
             if (fastGet(this, global, @field(BuiltinName, property))) |prop| {
                 if (prop.isEmptyOrUndefinedOrNull()) return null;
@@ -5327,8 +5550,9 @@ pub const JSValue = enum(JSValueReprInt) {
         return getTruthy(this, global, property);
     }
 
-    pub fn getTruthy(this: JSValue, global: *JSGlobalObject, property: []const u8) ?JSValue {
-        if (get(this, global, property)) |prop| {
+    // TODO: replace calls to this function with `getOptional`
+    pub fn getTruthy(this: JSValue, global: *JSGlobalObject, property: []const u8) bun.JSError!?JSValue {
+        if (try get2(this, global, property)) |prop| {
             if (prop.isEmptyOrUndefinedOrNull()) return null;
             return prop;
         }
@@ -5421,8 +5645,7 @@ pub const JSValue = enum(JSValueReprInt) {
 
     pub fn coerceToArray(prop: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8) JSError!?JSValue {
         if (!prop.jsTypeLoose().isArray()) {
-            globalThis.throwInvalidArguments(property_name ++ " must be an array", .{});
-            return error.JSError;
+            return globalThis.throwInvalidArguments2(property_name ++ " must be an array", .{});
         }
 
         if (prop.getLength(globalThis) == 0) {
@@ -5433,7 +5656,7 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     pub fn getArray(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8) JSError!?JSValue {
-        if (getTruthy(this, globalThis, property_name)) |prop| {
+        if (try this.getOptional(globalThis, property_name, JSValue)) |prop| {
             return coerceToArray(prop, globalThis, property_name);
         }
 
@@ -5449,7 +5672,7 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     pub fn getObject(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8) JSError!?JSValue {
-        if (getTruthy(this, globalThis, property_name)) |prop| {
+        if (try this.getOptional(globalThis, property_name, JSValue)) |prop| {
             if (!prop.jsTypeLoose().isObject()) {
                 globalThis.throwInvalidArguments(property_name ++ " must be an object", .{});
                 return error.JSError;
@@ -5475,7 +5698,7 @@ pub const JSValue = enum(JSValueReprInt) {
     }
 
     pub fn getFunction(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8) JSError!?JSValue {
-        if (getTruthy(this, globalThis, property_name)) |prop| {
+        if (try this.getOptional(globalThis, property_name, JSValue)) |prop| {
             if (!prop.isCell() or !prop.isCallable(globalThis.vm())) {
                 globalThis.throwInvalidArguments(property_name ++ " must be a function", .{});
                 return error.JSError;
@@ -5499,41 +5722,52 @@ pub const JSValue = enum(JSValueReprInt) {
 
         return null;
     }
-    fn coerceOptional(prop: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8, comptime T: type) JSError!?T {
-        switch (comptime T) {
-            bool => {
-                if (prop.isBoolean()) {
-                    return prop.toBoolean();
-                }
-
-                if (prop.isNumber()) {
-                    return prop.coerce(f64, globalThis) != 0;
-                }
 
-                globalThis.throwInvalidArguments(property_name ++ " must be a boolean", .{});
-                return error.JSError;
-            },
+    fn coerceOptional(prop: JSValue, global: *JSGlobalObject, comptime property_name: []const u8, comptime T: type) JSError!?T {
+        switch (comptime T) {
+            JSValue => return prop,
+            bool => @compileError("ambiguous coercion: use getBooleanStrict (throw error if not boolean) or getBooleanLoose (truthy check, never throws)"),
             ZigString.Slice => {
                 if (prop.isString()) {
-                    if (return prop.toSliceOrNull(globalThis)) |str| {
+                    if (return prop.toSliceOrNull(global)) |str| {
                         return str;
                     }
                 }
 
-                globalThis.throwInvalidArguments(property_name ++ " must be a string", .{});
-                return error.JSError;
+                return JSC.Node.validators.throwErrInvalidArgType(global, property_name, .{}, "string", prop);
             },
             else => @compileError("TODO:" ++ @typeName(T)),
         }
     }
 
-    pub fn getOptional(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8, comptime T: type) JSError!?T {
-        const prop = (if (comptime BuiltinName.has(property_name))
-            fastGet(this, globalThis, @field(BuiltinName, property_name))
-        else
-            get(this, globalThis, property_name)) orelse return null;
+    /// Many Bun API are loose and simply want to check if a value is truthy
+    /// Missing value, null, and undefined return `null`
+    pub inline fn getBooleanLoose(this: JSValue, global: *JSGlobalObject, comptime property_name: []const u8) JSError!?bool {
+        const prop = try this.get2(global, property_name) orelse
+            return null;
+        return prop.toBoolean();
+    }
 
-        if (!prop.isEmptyOrUndefinedOrNull()) {
+    /// Many Node.js APIs use `validateBoolean`
+    /// Missing value, null, and undefined return `null`
+    pub inline fn getBooleanStrict(this: JSValue, global: *JSGlobalObject, comptime property_name: []const u8) JSError!?bool {
+        const prop = try this.get2(global, property_name) orelse
+            return null;
+
+        return switch (prop) {
+            .null, .undefined => null,
+            .false, .true => prop == .true,
+            else => {
+                return JSC.Node.validators.throwErrInvalidArgType(global, property_name, .{}, "boolean", prop);
+            },
+        };
+    }
+
+    pub inline fn getOptional(this: JSValue, globalThis: *JSGlobalObject, comptime property_name: []const u8, comptime T: type) JSError!?T {
+        const prop = try this.get2(globalThis, property_name) orelse return null;
+        bun.assert(prop != .zero);
+
+        if (!prop.isUndefinedOrNull()) {
             return coerceOptional(prop, globalThis, property_name, T);
         }
 
@@ -5627,6 +5861,12 @@ pub const JSValue = enum(JSValueReprInt) {
         });
     }
 
+    extern fn JSC__JSValue__getUTCTimestamp(globalObject: *JSC.JSGlobalObject, this: JSValue) f64;
+    /// Calls getTime() - getUTCT
+    pub fn getUTCTimestamp(this: JSValue, globalObject: *JSC.JSGlobalObject) f64 {
+        return JSC__JSValue__getUTCTimestamp(globalObject, this);
+    }
+
     pub const StringFormatter = struct {
         value: JSC.JSValue,
         globalObject: *JSC.JSGlobalObject,
@@ -5720,6 +5960,7 @@ pub const JSValue = enum(JSValueReprInt) {
         return fromPtrAddress(@intFromPtr(addr));
     }
 
+    /// Equivalent to the `!!` operator
     pub fn toBoolean(this: JSValue) bool {
         return this != .zero and cppFn("toBoolean", .{this});
     }
@@ -5879,25 +6120,28 @@ pub const JSValue = enum(JSValueReprInt) {
         return cppFn("stringIncludes", .{ this, globalObject, other });
     }
 
+    // TODO: remove this (no replacement)
     pub inline fn asRef(this: JSValue) C_API.JSValueRef {
         return @as(C_API.JSValueRef, @ptrFromInt(@as(usize, @bitCast(@intFromEnum(this)))));
     }
 
+    // TODO: remove this (no replacement)
     pub inline fn c(this: C_API.JSValueRef) JSValue {
-        return @as(JSValue, @enumFromInt(@as(JSValue.Type, @bitCast(@intFromPtr(this)))));
+        return @as(JSValue, @enumFromInt(@as(JSValueReprInt, @bitCast(@intFromPtr(this)))));
     }
 
+    // TODO: remove this (no replacement)
     pub inline fn fromRef(this: C_API.JSValueRef) JSValue {
-        return @as(JSValue, @enumFromInt(@as(JSValue.Type, @bitCast(@intFromPtr(this)))));
+        return @as(JSValue, @enumFromInt(@as(JSValueReprInt, @bitCast(@intFromPtr(this)))));
     }
 
+    // TODO: remove this (no replacement)
     pub inline fn asObjectRef(this: JSValue) C_API.JSObjectRef {
         return @as(C_API.JSObjectRef, @ptrCast(this.asVoid()));
     }
 
-    /// When the GC sees a JSValue referenced in the stack
-    /// It knows not to free it
-    /// This mimicks the implementation in JavaScriptCore's C++
+    /// When the GC sees a JSValue referenced in the stack, it knows not to free it
+    /// This mimics the implementation in JavaScriptCore's C++
     pub inline fn ensureStillAlive(this: JSValue) void {
         if (!this.isCell()) return;
         std.mem.doNotOptimizeAway(this.asEncoded().asPtr);
@@ -5916,6 +6160,16 @@ pub const JSValue = enum(JSValueReprInt) {
         return this.asNullableVoid().?;
     }
 
+    /// Returns null if not an object.
+    // TODO: replace "getObject" to this, which would match JSC::JSValue in C++
+    pub inline fn getObject2(value: JSValue) ?*JSObject {
+        return if (value.isObject()) value.uncheckedPtrCast(JSObject) else null;
+    }
+
+    pub fn uncheckedPtrCast(value: JSValue, comptime T: type) *T {
+        return @alignCast(@ptrCast(value.asEncoded().asPtr));
+    }
+
     pub const Extern = [_][]const u8{
         "_then",
         "asArrayBuffer_",
@@ -6313,6 +6567,12 @@ pub const VM = extern struct {
         });
     }
 
+    // TODO: rewrite all `throwError` to use `JSError`
+    pub fn throwError2(vm: *VM, global_object: *JSGlobalObject, value: JSValue) JSError {
+        vm.throwError(global_object, value);
+        return JSError.JSError;
+    }
+
     pub fn releaseWeakRefs(vm: *VM) void {
         return cppFn("releaseWeakRefs", .{vm});
     }
@@ -6440,6 +6700,20 @@ pub const CatchScope = extern struct {
     };
 };
 
+// TODO: callframe cleanup
+// - remove all references into sizegen.zig since it is no longer run and may become out of date
+// - remove all functions to retrieve arguments, replace with
+//   - arguments(*CallFrame) []const JSValue (when you want a full slice)
+//   - argumentsAsArray(*CallFrame, comptime len) [len]JSValue (common case due to destructuring)
+//   - argument(*CallFrame, i: usize) JSValue (return undefined if not present)
+//   - argumentCount(*CallFrame) usize
+//
+// argumentsPtr() -> arguments().ptr
+// arguments(n).ptr[k] -> argumentsAsArray(n)[k]
+// arguments(n).slice() -> arguments()
+// arguments(n).mut() -> `var args = argumentsAsArray(n); &args`
+// argumentsCount() -> argumentCount() (to match JSC)
+// argument(n) -> arguments().ptr[n]
 pub const CallFrame = opaque {
     /// The value is generated in `make sizegen`
     /// The value is 6.
@@ -6514,10 +6788,6 @@ pub const CallFrame = opaque {
                 return self.ptr[0..self.len];
             }
 
-            pub inline fn all(self: *const @This()) []const JSValue {
-                return self.ptr[0..];
-            }
-
             pub inline fn mut(self: *@This()) []JSValue {
                 return self.ptr[0..];
             }
@@ -6529,7 +6799,7 @@ pub const CallFrame = opaque {
         const ptr = self.argumentsPtr();
         return switch (@as(u4, @min(len, max))) {
             0 => .{ .ptr = undefined, .len = 0 },
-            inline 1...9 => |count| Arguments(max).init(comptime @min(count, max), ptr),
+            inline 1...10 => |count| Arguments(max).init(comptime @min(count, max), ptr),
             else => unreachable,
         };
     }
@@ -6544,7 +6814,7 @@ pub const CallFrame = opaque {
         };
     }
 
-    pub fn argument(self: *const CallFrame, comptime i: comptime_int) JSC.JSValue {
+    pub inline fn argument(self: *const CallFrame, i: usize) JSC.JSValue {
         return self.argumentsPtr()[i];
     }
 
@@ -6555,33 +6825,19 @@ pub const CallFrame = opaque {
     pub fn argumentsCount(self: *const CallFrame) usize {
         return @as(usize, @intCast(self.asUnsafeJSValueArray()[Sizes.Bun_CallFrame__argumentCountIncludingThis].asInt32() - 1));
     }
-};
 
-// pub const WellKnownSymbols = extern struct {
-//     pub const shim = Shimmer("JSC", "CommonIdentifiers", @This());
-
-//
-//
+    extern fn Bun__CallFrame__isFromBunMain(*const CallFrame, *const VM) bool;
+    pub const isFromBunMain = Bun__CallFrame__isFromBunMain;
 
-//     pub const include = "JavaScriptCore/CommonIdentifiers.h";
-//     pub const name = "JSC::CommonIdentifiers";
-//     pub const namespace = "JSC";
-
-//     pub var hasthis: *const Identifier = shim.cppConst(Identifier, "hasInstance");
-//     pub var isConcatSpreadable: Identifier = shim.cppConst(Identifier, "isConcatSpreadable");
-//     pub var asyncIterator: Identifier = shim.cppConst(Identifier, "asyncIterator");
-//     pub var iterator: Identifier = shim.cppConst(Identifier, "iterator");
-//     pub var match: Identifier = shim.cppConst(Identifier, "match");
-//     pub var matchAll: Identifier = shim.cppConst(Identifier, "matchAll");
-//     pub var replace: Identifier = shim.cppConst(Identifier, "replace");
-//     pub var search: Identifier = shim.cppConst(Identifier, "search");
-//     pub var species: Identifier = shim.cppConst(Identifier, "species");
-//     pub var split: Identifier = shim.cppConst(Identifier, "split");
-//     pub var toPrimitive: Identifier = shim.cppConst(Identifier, "toPrimitive");
-//     pub var toStringTag: Identifier = shim.cppConst(Identifier, "toStringTag");
-//     pub var unscopable: Identifier = shim.cppConst(Identifier, "unscopabl");
-
-// };
+    /// Usage: `const arg1, const arg2 = call_frame.argumentsAsArray(2);`
+    pub fn argumentsAsArray(call_frame: *const CallFrame, comptime count: usize) [count]JSValue {
+        var value: [count]JSValue = .{.undefined} ** count;
+        for (0..@min(call_frame.argumentsCount(), count)) |i| {
+            value[i] = call_frame.argument(i);
+        }
+        return value;
+    }
+};
 
 pub const EncodedJSValue = extern union {
     asInt64: i64,
@@ -6593,39 +6849,46 @@ pub const EncodedJSValue = extern union {
 pub const JSHostFunctionType = fn (*JSGlobalObject, *CallFrame) callconv(JSC.conv) JSValue;
 pub const JSHostFunctionTypeWithCCallConvForAssertions = fn (*JSGlobalObject, *CallFrame) callconv(.C) JSValue;
 pub const JSHostFunctionPtr = *const JSHostFunctionType;
-pub fn toJSHostFunction(comptime Function: anytype) JSC.JSHostFunctionType {
-    if (comptime @TypeOf(Function) == JSHostFunctionType) {
-        return Function;
-    }
-
-    if (@TypeOf(Function) == fn (*JSGlobalObject, *CallFrame) JSValue) {
-        // These may coerce to both, but we want to force it to be this kind.
-    } else if (@TypeOf(Function) == *const fn (*JSGlobalObject, *CallFrame) JSValue) {
-        @compileLog(Function, "use JSC.toJSHostFunction(Function) instead of JSC.toJSHostFunction(&Function)");
-    }
+pub const JSHostZigFunction = fn (*JSGlobalObject, *CallFrame) bun.JSError!JSValue;
 
+pub fn toJSHostFunction(comptime Function: JSHostZigFunction) JSC.JSHostFunctionType {
     return struct {
         pub fn function(
             globalThis: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
         ) callconv(JSC.conv) JSC.JSValue {
-            comptime {
-                const Fn = @TypeOf(Function);
-                var FnTypeInfo = @typeInfo(Fn);
-                if (FnTypeInfo == .Pointer) {
-                    FnTypeInfo = @typeInfo(std.meta.Child(Fn));
-                }
+            return @call(.always_inline, Function, .{ globalThis, callframe }) catch |err| switch (err) {
+                error.JSError => .zero,
+                error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+            };
+        }
+    }.function;
+}
 
-                if (bun.Environment.isWindows) {
-                    if (FnTypeInfo.Fn.calling_convention == .C) {
-                        @compileLog(Function, "use callconv(JSC.conv) instead of callconv(.C), or don't set a callconv on the function.");
-                    }
-                }
-            }
+// XXX: temporary
+pub fn toJSHostValue(globalThis: *JSGlobalObject, value: error{ OutOfMemory, JSError }!JSValue) JSValue {
+    return value catch |err| switch (err) {
+        error.JSError => .zero,
+        error.OutOfMemory => globalThis.throwOutOfMemoryValue(),
+    };
+}
 
-            return @call(.always_inline, Function, .{ globalThis, callframe });
+const ParsedHostFunctionErrorSet = struct {
+    OutOfMemory: bool = false,
+    JSError: bool = false,
+};
+
+inline fn parseErrorSet(T: type, errors: []const std.builtin.Type.Error) ParsedHostFunctionErrorSet {
+    return comptime brk: {
+        var errs: ParsedHostFunctionErrorSet = .{};
+        for (errors) |err| {
+            if (!@hasField(ParsedHostFunctionErrorSet, err.name)) {
+                @compileError("Return value from host function '" ++ @typeInfo(T) ++ "' can not contain error '" ++ err.name ++ "'");
+            }
+            @field(errs, err.name) = true;
         }
-    }.function;
+        break :brk errs;
+    };
 }
 
 const DeinitFunction = *const fn (ctx: *anyopaque, buffer: [*]u8, len: usize) callconv(.C) void;
@@ -6691,6 +6954,9 @@ pub fn NewFunction(
     comptime functionPointer: anytype,
     strong: bool,
 ) JSValue {
+    if (@TypeOf(functionPointer) == JSC.JSHostFunctionType) {
+        return NewRuntimeFunction(globalObject, symbolName, argCount, functionPointer, strong, false);
+    }
     return NewRuntimeFunction(globalObject, symbolName, argCount, toJSHostFunction(functionPointer), strong, false);
 }
 
@@ -6700,6 +6966,9 @@ pub fn createCallback(
     argCount: u32,
     comptime functionPointer: anytype,
 ) JSValue {
+    if (@TypeOf(functionPointer) == JSC.JSHostFunctionType) {
+        return NewRuntimeFunction(globalObject, symbolName, argCount, functionPointer, false, false);
+    }
     return NewRuntimeFunction(globalObject, symbolName, argCount, toJSHostFunction(functionPointer), false, false);
 }
 
@@ -6729,7 +6998,7 @@ pub fn NewFunctionWithData(
     globalObject: *JSGlobalObject,
     symbolName: ?*const ZigString,
     argCount: u32,
-    comptime functionPointer: anytype,
+    comptime functionPointer: JSC.JSHostZigFunction,
     strong: bool,
     data: *anyopaque,
 ) JSValue {
@@ -6798,14 +7067,18 @@ pub const URL = opaque {
 
     /// This percent-encodes the URL, punycode-encodes the hostname, and returns the result
     /// If it fails, the tag is marked Dead
-    pub fn hrefFromJS(value: JSValue, globalObject: *JSC.JSGlobalObject) String {
+    pub fn hrefFromJS(value: JSValue, globalObject: *JSC.JSGlobalObject) bun.JSError!String {
         JSC.markBinding(@src());
-        return URL__getHrefFromJS(value, globalObject);
+        const result = URL__getHrefFromJS(value, globalObject);
+        if (globalObject.hasException()) return error.JSError;
+        return result;
     }
 
-    pub fn fromJS(value: JSValue, globalObject: *JSC.JSGlobalObject) ?*URL {
+    pub fn fromJS(value: JSValue, globalObject: *JSC.JSGlobalObject) bun.JSError!?*URL {
         JSC.markBinding(@src());
-        return URL__fromJS(value, globalObject);
+        const result = URL__fromJS(value, globalObject);
+        if (globalObject.hasException()) return error.JSError;
+        return result;
     }
 
     pub fn fromUTF8(input: []const u8) ?*URL {
diff --git a/src/bun.js/bindings/c-bindings.cpp b/src/bun.js/bindings/c-bindings.cpp
index 0d229cc0dfe0a6..906fc01e812373 100644
--- a/src/bun.js/bindings/c-bindings.cpp
+++ b/src/bun.js/bindings/c-bindings.cpp
@@ -557,7 +557,7 @@ extern "C" void bun_initialize_process()
 
 #if OS(DARWIN)
     atexit(Bun__onExit);
-#else
+#elif !OS(WINDOWS)
     at_quick_exit(Bun__onExit);
 #endif
 }
diff --git a/src/bun.js/bindings/generated_classes_list.zig b/src/bun.js/bindings/generated_classes_list.zig
index f32a6a9b19b005..72095df5a58673 100644
--- a/src/bun.js/bindings/generated_classes_list.zig
+++ b/src/bun.js/bindings/generated_classes_list.zig
@@ -76,4 +76,5 @@ pub const Classes = struct {
     pub const TextEncoderStreamEncoder = JSC.WebCore.TextEncoderStreamEncoder;
     pub const NativeZlib = JSC.API.NativeZlib;
     pub const NativeBrotli = JSC.API.NativeBrotli;
+    pub const FrameworkFileSystemRouter = bun.bake.FrameworkRouter.JSFrameworkRouter;
 };
diff --git a/src/bun.js/bindings/headers.h b/src/bun.js/bindings/headers.h
index 7cc6afdecd2bbd..b8d1cfd64b158c 100644
--- a/src/bun.js/bindings/headers.h
+++ b/src/bun.js/bindings/headers.h
@@ -323,7 +323,7 @@ CPP_DECL bool JSC__JSValue__deepEquals(JSC__JSValue JSValue0, JSC__JSValue JSVal
 CPP_DECL bool JSC__JSValue__deepMatch(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, bool arg3);
 CPP_DECL bool JSC__JSValue__eqlCell(JSC__JSValue JSValue0, JSC__JSCell* arg1);
 CPP_DECL bool JSC__JSValue__eqlValue(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
-CPP_DECL JSC__JSValue JSC__JSValue__fastGet_(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, unsigned char arg2);
+CPP_DECL JSC__JSValue JSC__JSValue__fastGet(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, unsigned char arg2);
 CPP_DECL JSC__JSValue JSC__JSValue__fastGetDirect_(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, unsigned char arg2);
 CPP_DECL void JSC__JSValue__forEach(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void(* ArgFn3)(JSC__VM* arg0, JSC__JSGlobalObject* arg1, void* arg2, JSC__JSValue JSValue3));
 CPP_DECL void JSC__JSValue__forEachProperty(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void(* ArgFn3)(JSC__JSGlobalObject* arg0, void* arg1, ZigString* arg2, JSC__JSValue JSValue3, bool arg4, bool arg5));
diff --git a/src/bun.js/bindings/shimmer.zig b/src/bun.js/bindings/shimmer.zig
index 307294918ef415..79c3dec3d4e630 100644
--- a/src/bun.js/bindings/shimmer.zig
+++ b/src/bun.js/bindings/shimmer.zig
@@ -122,7 +122,11 @@ pub fn Shimmer(comptime _namespace: []const u8, comptime _name: []const u8, comp
                     const Fn: std.builtin.Type.Fn = @typeInfo(Function).Fn;
                     if (Function == bun.JSC.JSHostFunctionTypeWithCCallConvForAssertions and bun.JSC.conv != .C) {
                         @compileError("Expected " ++ bun.meta.typeName(Function) ++ " to have a JSC.conv Calling Convention.");
-                    } else if (Function == bun.JSC.JSHostFunctionType) {} else if (Fn.calling_convention != .C) {
+                    } else if (Function == bun.JSC.JSHostFunctionType) {
+                        //
+                    } else if (Function == bun.JSC.JSHostZigFunction) {
+                        //
+                    } else if (Fn.calling_convention != .C) {
                         @compileError("Expected " ++ @typeName(Parent) ++ "." ++ @typeName(Function) ++ " to have a C Calling Convention.");
                     }
 
diff --git a/src/bun.js/bindings/sizes.zig b/src/bun.js/bindings/sizes.zig
index 795159e49f3f31..39170e898046f0 100644
--- a/src/bun.js/bindings/sizes.zig
+++ b/src/bun.js/bindings/sizes.zig
@@ -1,81 +1,13 @@
-// Auto-generated by src/bun.js/headergen/sizegen.cpp at 2022-11-24 20:03:1669349010.
-// These are the byte sizes for the different object types with bindings in JavaScriptCore.
-// This allows us to safely return stack allocated C++ types to Zig.
-// It is only safe to do this when these sizes are correct.
-// That means:
-// 1. We can't dynamically link JavaScriptCore
-// 2. It's important that this is run whenever JavaScriptCore is updated or the bindings on the Zig side change.
-//    Failure to do so will lead to undefined behavior and probably some frustrated people.
-// --- Regenerate this: ---
-// 1. "make headers"
-// 2. "make sizegen"
-// 3. "make headers"
-// ------------------------
-// You can verify the numbers written in this file at runtime via the `extern`d types
-// Run "headers" twice because it uses these values in the output. That's how all the bJSC__.* types are created - from these values.
-pub const JSC__JSObject = 16;
-pub const JSC__JSObject_align = 8;
-pub const WebCore__DOMURL = 112;
-pub const WebCore__DOMURL_align = 8;
-pub const WebCore__FetchHeaders = 56;
-pub const WebCore__FetchHeaders_align = 8;
-pub const SystemError = 80;
-pub const SystemError_align = 8;
-pub const JSC__JSCell = 8;
-pub const JSC__JSCell_align = 4;
-pub const JSC__JSString = 16;
-pub const JSC__JSString_align = 8;
-pub const Inspector__ScriptArguments = 32;
-pub const Inspector__ScriptArguments_align = 8;
-pub const JSC__JSModuleLoader = 16;
-pub const JSC__JSModuleLoader_align = 8;
-pub const JSC__JSModuleRecord = 216;
-pub const JSC__JSModuleRecord_align = 8;
-pub const JSC__JSPromise = 32;
-pub const JSC__JSPromise_align = 8;
-pub const JSC__JSInternalPromise = 32;
-pub const JSC__JSInternalPromise_align = 8;
-pub const JSC__SourceOrigin = 48;
-pub const JSC__SourceOrigin_align = 8;
-pub const JSC__SourceCode = 24;
-pub const JSC__SourceCode_align = 8;
-pub const JSC__JSFunction = 32;
-pub const JSC__JSFunction_align = 8;
-pub const JSC__JSGlobalObject = 3128;
-pub const JSC__JSGlobalObject_align = 8;
-pub const WTF__URL = 40;
-pub const WTF__URL_align = 8;
-pub const WTF__String = 8;
-pub const WTF__String_align = 8;
-pub const JSC__JSValue = 8;
-pub const JSC__JSValue_align = 8;
-pub const JSC__PropertyName = 8;
-pub const JSC__PropertyName_align = 8;
-pub const JSC__Exception = 40;
-pub const JSC__Exception_align = 8;
-pub const JSC__VM = 52176;
-pub const JSC__VM_align = 8;
-pub const JSC__ThrowScope = 8;
-pub const JSC__ThrowScope_align = 8;
-pub const JSC__CatchScope = 8;
-pub const JSC__CatchScope_align = 8;
-pub const JSC__Identifier = 8;
-pub const JSC__Identifier_align = 8;
-pub const WTF__StringImpl = 24;
-pub const WTF__StringImpl_align = 8;
-pub const WTF__ExternalStringImpl = 40;
-pub const WTF__ExternalStringImpl_align = 8;
-pub const WTF__StringView = 16;
-pub const WTF__StringView_align = 8;
-pub const Zig__GlobalObject = 6496;
-pub const Zig__GlobalObject_align = 8;
+//! This namespace contains JSC C++ type sizes/alignments exported from a code
+//! generator Do not rely on any of these values in new code. If possible,
+//! rewrite old ones to use another approach.
+//!
+//! It is not reliable to interpret C++ classes as raw bytes, since the
+//! memory layout is not guaranteed by the compiler.
 pub const Bun_FFI_PointerOffsetToArgumentsList = 6;
 pub const Bun_FFI_PointerOffsetToTypedArrayVector = 16;
-pub const Bun_FFI_PointerOffsetToTypedArrayLength = 24;
-pub const Bun_CallFrame__codeBlock = 2;
 pub const Bun_CallFrame__callee = 3;
 pub const Bun_CallFrame__argumentCountIncludingThis = 4;
 pub const Bun_CallFrame__thisArgument = 5;
 pub const Bun_CallFrame__firstArgument = 6;
-pub const Bun_CallFrame__size = 8;
 pub const Bun_CallFrame__align = 8;
diff --git a/src/bun.js/bindings/sqlite/JSSQLStatement.cpp b/src/bun.js/bindings/sqlite/JSSQLStatement.cpp
index fbea93cc7eed80..be8ff4b90bc12d 100644
--- a/src/bun.js/bindings/sqlite/JSSQLStatement.cpp
+++ b/src/bun.js/bindings/sqlite/JSSQLStatement.cpp
@@ -153,10 +153,10 @@ static void sqlite_free_typed_array(void* ctx, void* buf)
     sqlite3_free((void*)buf);
 }
 
-static int DEFAULT_SQLITE_FLAGS
+static constexpr int DEFAULT_SQLITE_FLAGS
     = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
-static unsigned int DEFAULT_SQLITE_PREPARE_FLAGS = SQLITE_PREPARE_PERSISTENT;
-static int MAX_SQLITE_PREPARE_FLAG = SQLITE_PREPARE_PERSISTENT | SQLITE_PREPARE_NORMALIZE | SQLITE_PREPARE_NO_VTAB;
+static constexpr unsigned int DEFAULT_SQLITE_PREPARE_FLAGS = SQLITE_PREPARE_PERSISTENT;
+static constexpr int MAX_SQLITE_PREPARE_FLAG = SQLITE_PREPARE_PERSISTENT | SQLITE_PREPARE_NORMALIZE | SQLITE_PREPARE_NO_VTAB;
 
 static inline JSC::JSValue jsNumberFromSQLite(sqlite3_stmt* stmt, unsigned int i)
 {
diff --git a/src/bun.js/bindings/webcore/FetchHeaders.cpp b/src/bun.js/bindings/webcore/FetchHeaders.cpp
index 127f6d29a19d83..f50fdc8923f050 100644
--- a/src/bun.js/bindings/webcore/FetchHeaders.cpp
+++ b/src/bun.js/bindings/webcore/FetchHeaders.cpp
@@ -338,7 +338,7 @@ std::optional<KeyValuePair<String, String>> FetchHeaders::Iterator::next()
         if (key.isNull()) {
             if (m_cookieIndex < setCookieHeaders.size()) {
                 String value = setCookieHeaders[m_cookieIndex++];
-                return KeyValuePair<String, String> { WTF::staticHeaderNames[static_cast<uint8_t>(HTTPHeaderName::SetCookie)], WTFMove(value) };
+                return KeyValuePair<String, String> { WTF::httpHeaderNameStringImpl(HTTPHeaderName::SetCookie), WTFMove(value) };
             }
             m_currentIndex++;
             continue;
diff --git a/src/bun.js/bindings/webcore/FetchHeaders.h b/src/bun.js/bindings/webcore/FetchHeaders.h
index 8e3713539b578d..e28db4f9666b2a 100644
--- a/src/bun.js/bindings/webcore/FetchHeaders.h
+++ b/src/bun.js/bindings/webcore/FetchHeaders.h
@@ -71,12 +71,12 @@ class FetchHeaders : public RefCounted<FetchHeaders> {
 
     size_t memoryCost() const;
 
-    inline uint32_t size()
+    inline uint32_t size() const
     {
         return m_headers.size();
     }
 
-    inline uint32_t sizeAfterJoiningSetCookieHeader()
+    inline uint32_t sizeAfterJoiningSetCookieHeader() const
     {
         return m_headers.commonHeaders().size() + m_headers.uncommonHeaders().size() + (m_headers.getSetCookieHeaders().size() > 0);
     }
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderNames.h b/src/bun.js/bindings/webcore/HTTPHeaderNames.h
index 37b7ffb4e425ca..42db45a00f70b8 100644
--- a/src/bun.js/bindings/webcore/HTTPHeaderNames.h
+++ b/src/bun.js/bindings/webcore/HTTPHeaderNames.h
@@ -26,8 +26,7 @@
 
 /// This file is generated by create-http-header-name-table, do not edit.
 
-#ifndef HTTPHeaderNames_h
-#define HTTPHeaderNames_h
+#pragma once
 
 #include <wtf/Forward.h>
 
@@ -238,206 +237,7 @@ template<> struct EnumTraits<WebCore::HTTPHeaderName> {
         WebCore::HTTPHeaderName::XXSSProtection>;
 };
 
-static const NeverDestroyed<String> staticHeaderNames[] = {
-    MAKE_STATIC_STRING_IMPL("accept"),
-    MAKE_STATIC_STRING_IMPL("accept-charset"),
-    MAKE_STATIC_STRING_IMPL("accept-encoding"),
-    MAKE_STATIC_STRING_IMPL("accept-language"),
-    MAKE_STATIC_STRING_IMPL("accept-ranges"),
-    MAKE_STATIC_STRING_IMPL("access-control-allow-credentials"),
-    MAKE_STATIC_STRING_IMPL("access-control-allow-headers"),
-    MAKE_STATIC_STRING_IMPL("access-control-allow-methods"),
-    MAKE_STATIC_STRING_IMPL("access-control-allow-origin"),
-    MAKE_STATIC_STRING_IMPL("access-control-expose-headers"),
-    MAKE_STATIC_STRING_IMPL("access-control-max-age"),
-    MAKE_STATIC_STRING_IMPL("access-control-request-headers"),
-    MAKE_STATIC_STRING_IMPL("access-control-request-method"),
-    MAKE_STATIC_STRING_IMPL("age"),
-    MAKE_STATIC_STRING_IMPL("authorization"),
-    MAKE_STATIC_STRING_IMPL("cache-control"),
-    MAKE_STATIC_STRING_IMPL("connection"),
-    MAKE_STATIC_STRING_IMPL("content-disposition"),
-    MAKE_STATIC_STRING_IMPL("content-encoding"),
-    MAKE_STATIC_STRING_IMPL("content-language"),
-    MAKE_STATIC_STRING_IMPL("content-length"),
-    MAKE_STATIC_STRING_IMPL("content-location"),
-    MAKE_STATIC_STRING_IMPL("content-range"),
-    MAKE_STATIC_STRING_IMPL("content-security-policy"),
-    MAKE_STATIC_STRING_IMPL("content-security-policy-report-only"),
-    MAKE_STATIC_STRING_IMPL("content-type"),
-    MAKE_STATIC_STRING_IMPL("cookie"),
-    MAKE_STATIC_STRING_IMPL("cookie2"),
-    MAKE_STATIC_STRING_IMPL("cross-origin-embedder-policy"),
-    MAKE_STATIC_STRING_IMPL("cross-origin-embedder-policy-report-only"),
-    MAKE_STATIC_STRING_IMPL("cross-origin-opener-policy"),
-    MAKE_STATIC_STRING_IMPL("cross-origin-opener-policy-report-only"),
-    MAKE_STATIC_STRING_IMPL("cross-origin-resource-policy"),
-    MAKE_STATIC_STRING_IMPL("dnt"),
-    MAKE_STATIC_STRING_IMPL("date"),
-    MAKE_STATIC_STRING_IMPL("default-style"),
-    MAKE_STATIC_STRING_IMPL("etag"),
-    MAKE_STATIC_STRING_IMPL("expect"),
-    MAKE_STATIC_STRING_IMPL("expires"),
-    MAKE_STATIC_STRING_IMPL("host"),
-    MAKE_STATIC_STRING_IMPL("icy-metaint"),
-    MAKE_STATIC_STRING_IMPL("icy-metadata"),
-    MAKE_STATIC_STRING_IMPL("if-match"),
-    MAKE_STATIC_STRING_IMPL("if-modified-since"),
-    MAKE_STATIC_STRING_IMPL("if-none-match"),
-    MAKE_STATIC_STRING_IMPL("if-range"),
-    MAKE_STATIC_STRING_IMPL("if-unmodified-since"),
-    MAKE_STATIC_STRING_IMPL("keep-alive"),
-    MAKE_STATIC_STRING_IMPL("last-event-id"),
-    MAKE_STATIC_STRING_IMPL("last-modified"),
-    MAKE_STATIC_STRING_IMPL("link"),
-    MAKE_STATIC_STRING_IMPL("location"),
-    MAKE_STATIC_STRING_IMPL("origin"),
-    MAKE_STATIC_STRING_IMPL("ping-from"),
-    MAKE_STATIC_STRING_IMPL("ping-to"),
-    MAKE_STATIC_STRING_IMPL("pragma"),
-    MAKE_STATIC_STRING_IMPL("proxy-authorization"),
-    MAKE_STATIC_STRING_IMPL("purpose"),
-    MAKE_STATIC_STRING_IMPL("range"),
-    MAKE_STATIC_STRING_IMPL("referer"),
-    MAKE_STATIC_STRING_IMPL("referrer-policy"),
-    MAKE_STATIC_STRING_IMPL("refresh"),
-    MAKE_STATIC_STRING_IMPL("report-to"),
-    MAKE_STATIC_STRING_IMPL("sec-fetch-dest"),
-    MAKE_STATIC_STRING_IMPL("sec-fetch-mode"),
-    MAKE_STATIC_STRING_IMPL("sec-websocket-accept"),
-    MAKE_STATIC_STRING_IMPL("sec-websocket-extensions"),
-    MAKE_STATIC_STRING_IMPL("sec-websocket-key"),
-    MAKE_STATIC_STRING_IMPL("sec-websocket-protocol"),
-    MAKE_STATIC_STRING_IMPL("sec-websocket-version"),
-    MAKE_STATIC_STRING_IMPL("server-timing"),
-    MAKE_STATIC_STRING_IMPL("service-worker"),
-    MAKE_STATIC_STRING_IMPL("service-worker-allowed"),
-    MAKE_STATIC_STRING_IMPL("service-worker-navigation-preload"),
-    MAKE_STATIC_STRING_IMPL("set-cookie"),
-    MAKE_STATIC_STRING_IMPL("set-cookie2"),
-    MAKE_STATIC_STRING_IMPL("sourcemap"),
-    MAKE_STATIC_STRING_IMPL("strict-transport-security"),
-    MAKE_STATIC_STRING_IMPL("te"),
-    MAKE_STATIC_STRING_IMPL("timing-allow-origin"),
-    MAKE_STATIC_STRING_IMPL("trailer"),
-    MAKE_STATIC_STRING_IMPL("transfer-encoding"),
-    MAKE_STATIC_STRING_IMPL("upgrade"),
-    MAKE_STATIC_STRING_IMPL("upgrade-insecure-requests"),
-    MAKE_STATIC_STRING_IMPL("user-agent"),
-    MAKE_STATIC_STRING_IMPL("vary"),
-    MAKE_STATIC_STRING_IMPL("via"),
-    MAKE_STATIC_STRING_IMPL("x-content-type-options"),
-    MAKE_STATIC_STRING_IMPL("x-dns-prefetch-control"),
-    MAKE_STATIC_STRING_IMPL("x-frame-options"),
-    MAKE_STATIC_STRING_IMPL("x-sourcemap"),
-    MAKE_STATIC_STRING_IMPL("x-temp-tablet"),
-    MAKE_STATIC_STRING_IMPL("x-xss-protection"),
-};
-
-static const NeverDestroyed<String> staticHeaderNamesDefaultCase[] = {
-    MAKE_STATIC_STRING_IMPL("Accept"),
-    MAKE_STATIC_STRING_IMPL("Accept-Charset"),
-    MAKE_STATIC_STRING_IMPL("Accept-Encoding"),
-    MAKE_STATIC_STRING_IMPL("Accept-Language"),
-    MAKE_STATIC_STRING_IMPL("Accept-Ranges"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Credentials"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Headers"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Methods"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Origin"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Expose-Headers"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Max-Age"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Request-Headers"),
-    MAKE_STATIC_STRING_IMPL("Access-Control-Request-Method"),
-    MAKE_STATIC_STRING_IMPL("Age"),
-    MAKE_STATIC_STRING_IMPL("Authorization"),
-    MAKE_STATIC_STRING_IMPL("Cache-Control"),
-    MAKE_STATIC_STRING_IMPL("Connection"),
-    MAKE_STATIC_STRING_IMPL("Content-Disposition"),
-    MAKE_STATIC_STRING_IMPL("Content-Encoding"),
-    MAKE_STATIC_STRING_IMPL("Content-Language"),
-    MAKE_STATIC_STRING_IMPL("Content-Length"),
-    MAKE_STATIC_STRING_IMPL("Content-Location"),
-    MAKE_STATIC_STRING_IMPL("Content-Range"),
-    MAKE_STATIC_STRING_IMPL("Content-Security-Policy"),
-    MAKE_STATIC_STRING_IMPL("Content-Security-Policy-Report-Only"),
-    MAKE_STATIC_STRING_IMPL("Content-Type"),
-    MAKE_STATIC_STRING_IMPL("Cookie"),
-    MAKE_STATIC_STRING_IMPL("Cookie2"),
-    MAKE_STATIC_STRING_IMPL("Cross-Origin-Embedder-Policy"),
-    MAKE_STATIC_STRING_IMPL("Cross-Origin-Embedder-Policy-Report-Only"),
-    MAKE_STATIC_STRING_IMPL("Cross-Origin-Opener-Policy"),
-    MAKE_STATIC_STRING_IMPL("Cross-Origin-Opener-Policy-Report-Only"),
-    MAKE_STATIC_STRING_IMPL("Cross-Origin-Resource-Policy"),
-    MAKE_STATIC_STRING_IMPL("DNT"),
-    MAKE_STATIC_STRING_IMPL("Date"),
-    MAKE_STATIC_STRING_IMPL("Default-Style"),
-    MAKE_STATIC_STRING_IMPL("ETag"),
-    MAKE_STATIC_STRING_IMPL("Expect"),
-    MAKE_STATIC_STRING_IMPL("Expires"),
-    MAKE_STATIC_STRING_IMPL("Host"),
-    MAKE_STATIC_STRING_IMPL("Icy-Metaint"),
-    MAKE_STATIC_STRING_IMPL("Icy-Metadata"),
-    MAKE_STATIC_STRING_IMPL("If-Match"),
-    MAKE_STATIC_STRING_IMPL("If-Modified-Since"),
-    MAKE_STATIC_STRING_IMPL("If-None-Match"),
-    MAKE_STATIC_STRING_IMPL("If-Range"),
-    MAKE_STATIC_STRING_IMPL("If-Unmodified-Since"),
-    MAKE_STATIC_STRING_IMPL("Keep-Alive"),
-    MAKE_STATIC_STRING_IMPL("Last-Event-Id"),
-    MAKE_STATIC_STRING_IMPL("Last-Modified"),
-    MAKE_STATIC_STRING_IMPL("Link"),
-    MAKE_STATIC_STRING_IMPL("Location"),
-    MAKE_STATIC_STRING_IMPL("Origin"),
-    MAKE_STATIC_STRING_IMPL("Ping-From"),
-    MAKE_STATIC_STRING_IMPL("Ping-To"),
-    MAKE_STATIC_STRING_IMPL("Pragma"),
-    MAKE_STATIC_STRING_IMPL("Proxy-Authorization"),
-    MAKE_STATIC_STRING_IMPL("Purpose"),
-    MAKE_STATIC_STRING_IMPL("Range"),
-    MAKE_STATIC_STRING_IMPL("Referer"),
-    MAKE_STATIC_STRING_IMPL("Referrer-Policy"),
-    MAKE_STATIC_STRING_IMPL("Refresh"),
-    MAKE_STATIC_STRING_IMPL("Report-To"),
-    MAKE_STATIC_STRING_IMPL("Sec-Fetch-Dest"),
-    MAKE_STATIC_STRING_IMPL("Sec-Fetch-Mode"),
-    MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Accept"),
-    MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Extensions"),
-    MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Key"),
-    MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Protocol"),
-    MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Version"),
-    MAKE_STATIC_STRING_IMPL("Server-Timing"),
-    MAKE_STATIC_STRING_IMPL("Service-Worker"),
-    MAKE_STATIC_STRING_IMPL("Service-Worker-Allowed"),
-    MAKE_STATIC_STRING_IMPL("Service-Worker-Navigation-Preload"),
-    MAKE_STATIC_STRING_IMPL("Set-Cookie"),
-    MAKE_STATIC_STRING_IMPL("Set-Cookie2"),
-    MAKE_STATIC_STRING_IMPL("Sourcemap"),
-    MAKE_STATIC_STRING_IMPL("Strict-Transport-Security"),
-    MAKE_STATIC_STRING_IMPL("TE"),
-    MAKE_STATIC_STRING_IMPL("Timing-Allow-Origin"),
-    MAKE_STATIC_STRING_IMPL("Trailer"),
-    MAKE_STATIC_STRING_IMPL("Transfer-Encoding"),
-    MAKE_STATIC_STRING_IMPL("Upgrade"),
-    MAKE_STATIC_STRING_IMPL("Upgrade-Insecure-Requests"),
-    MAKE_STATIC_STRING_IMPL("User-Agent"),
-    MAKE_STATIC_STRING_IMPL("Vary"),
-    MAKE_STATIC_STRING_IMPL("Via"),
-    MAKE_STATIC_STRING_IMPL("X-Content-Type-Options"),
-    MAKE_STATIC_STRING_IMPL("X-DNS-Prefetch-Control"),
-    MAKE_STATIC_STRING_IMPL("X-Frame-Options"),
-    MAKE_STATIC_STRING_IMPL("X-Sourcemap"),
-    MAKE_STATIC_STRING_IMPL("X-Temp-Tablet"),
-    MAKE_STATIC_STRING_IMPL("X-XSS-Protection"),
-};
-static const WTF::String& httpHeaderNameStringImpl(WebCore::HTTPHeaderName headerName)
-{
-    return staticHeaderNames[static_cast<size_t>(headerName)];
-}
-static const WTF::String& httpHeaderNameDefaultCaseStringImpl(WebCore::HTTPHeaderName headerName)
-{
-    return staticHeaderNamesDefaultCase[static_cast<size_t>(headerName)];
-}
+const WTF::String& httpHeaderNameStringImpl(WebCore::HTTPHeaderName headerName);
+const WTF::String& httpHeaderNameDefaultCaseStringImpl(WebCore::HTTPHeaderName headerName);
 
 } // namespace WTF
-
-#endif // HTTPHeaderNames_h
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderStrings.cpp b/src/bun.js/bindings/webcore/HTTPHeaderStrings.cpp
new file mode 100644
index 00000000000000..ffbd3589657b50
--- /dev/null
+++ b/src/bun.js/bindings/webcore/HTTPHeaderStrings.cpp
@@ -0,0 +1,210 @@
+#include "root.h"
+
+#include "HTTPHeaderNames.h"
+
+// This is a separate file so we avoid creating these static initializers in several files.
+
+namespace WTF {
+
+const WTF::String& httpHeaderNameStringImpl(WebCore::HTTPHeaderName headerName)
+{
+    static const NeverDestroyed<String> staticHeaderNames[] = {
+        MAKE_STATIC_STRING_IMPL("accept"),
+        MAKE_STATIC_STRING_IMPL("accept-charset"),
+        MAKE_STATIC_STRING_IMPL("accept-encoding"),
+        MAKE_STATIC_STRING_IMPL("accept-language"),
+        MAKE_STATIC_STRING_IMPL("accept-ranges"),
+        MAKE_STATIC_STRING_IMPL("access-control-allow-credentials"),
+        MAKE_STATIC_STRING_IMPL("access-control-allow-headers"),
+        MAKE_STATIC_STRING_IMPL("access-control-allow-methods"),
+        MAKE_STATIC_STRING_IMPL("access-control-allow-origin"),
+        MAKE_STATIC_STRING_IMPL("access-control-expose-headers"),
+        MAKE_STATIC_STRING_IMPL("access-control-max-age"),
+        MAKE_STATIC_STRING_IMPL("access-control-request-headers"),
+        MAKE_STATIC_STRING_IMPL("access-control-request-method"),
+        MAKE_STATIC_STRING_IMPL("age"),
+        MAKE_STATIC_STRING_IMPL("authorization"),
+        MAKE_STATIC_STRING_IMPL("cache-control"),
+        MAKE_STATIC_STRING_IMPL("connection"),
+        MAKE_STATIC_STRING_IMPL("content-disposition"),
+        MAKE_STATIC_STRING_IMPL("content-encoding"),
+        MAKE_STATIC_STRING_IMPL("content-language"),
+        MAKE_STATIC_STRING_IMPL("content-length"),
+        MAKE_STATIC_STRING_IMPL("content-location"),
+        MAKE_STATIC_STRING_IMPL("content-range"),
+        MAKE_STATIC_STRING_IMPL("content-security-policy"),
+        MAKE_STATIC_STRING_IMPL("content-security-policy-report-only"),
+        MAKE_STATIC_STRING_IMPL("content-type"),
+        MAKE_STATIC_STRING_IMPL("cookie"),
+        MAKE_STATIC_STRING_IMPL("cookie2"),
+        MAKE_STATIC_STRING_IMPL("cross-origin-embedder-policy"),
+        MAKE_STATIC_STRING_IMPL("cross-origin-embedder-policy-report-only"),
+        MAKE_STATIC_STRING_IMPL("cross-origin-opener-policy"),
+        MAKE_STATIC_STRING_IMPL("cross-origin-opener-policy-report-only"),
+        MAKE_STATIC_STRING_IMPL("cross-origin-resource-policy"),
+        MAKE_STATIC_STRING_IMPL("dnt"),
+        MAKE_STATIC_STRING_IMPL("date"),
+        MAKE_STATIC_STRING_IMPL("default-style"),
+        MAKE_STATIC_STRING_IMPL("etag"),
+        MAKE_STATIC_STRING_IMPL("expect"),
+        MAKE_STATIC_STRING_IMPL("expires"),
+        MAKE_STATIC_STRING_IMPL("host"),
+        MAKE_STATIC_STRING_IMPL("icy-metaint"),
+        MAKE_STATIC_STRING_IMPL("icy-metadata"),
+        MAKE_STATIC_STRING_IMPL("if-match"),
+        MAKE_STATIC_STRING_IMPL("if-modified-since"),
+        MAKE_STATIC_STRING_IMPL("if-none-match"),
+        MAKE_STATIC_STRING_IMPL("if-range"),
+        MAKE_STATIC_STRING_IMPL("if-unmodified-since"),
+        MAKE_STATIC_STRING_IMPL("keep-alive"),
+        MAKE_STATIC_STRING_IMPL("last-event-id"),
+        MAKE_STATIC_STRING_IMPL("last-modified"),
+        MAKE_STATIC_STRING_IMPL("link"),
+        MAKE_STATIC_STRING_IMPL("location"),
+        MAKE_STATIC_STRING_IMPL("origin"),
+        MAKE_STATIC_STRING_IMPL("ping-from"),
+        MAKE_STATIC_STRING_IMPL("ping-to"),
+        MAKE_STATIC_STRING_IMPL("pragma"),
+        MAKE_STATIC_STRING_IMPL("proxy-authorization"),
+        MAKE_STATIC_STRING_IMPL("purpose"),
+        MAKE_STATIC_STRING_IMPL("range"),
+        MAKE_STATIC_STRING_IMPL("referer"),
+        MAKE_STATIC_STRING_IMPL("referrer-policy"),
+        MAKE_STATIC_STRING_IMPL("refresh"),
+        MAKE_STATIC_STRING_IMPL("report-to"),
+        MAKE_STATIC_STRING_IMPL("sec-fetch-dest"),
+        MAKE_STATIC_STRING_IMPL("sec-fetch-mode"),
+        MAKE_STATIC_STRING_IMPL("sec-websocket-accept"),
+        MAKE_STATIC_STRING_IMPL("sec-websocket-extensions"),
+        MAKE_STATIC_STRING_IMPL("sec-websocket-key"),
+        MAKE_STATIC_STRING_IMPL("sec-websocket-protocol"),
+        MAKE_STATIC_STRING_IMPL("sec-websocket-version"),
+        MAKE_STATIC_STRING_IMPL("server-timing"),
+        MAKE_STATIC_STRING_IMPL("service-worker"),
+        MAKE_STATIC_STRING_IMPL("service-worker-allowed"),
+        MAKE_STATIC_STRING_IMPL("service-worker-navigation-preload"),
+        MAKE_STATIC_STRING_IMPL("set-cookie"),
+        MAKE_STATIC_STRING_IMPL("set-cookie2"),
+        MAKE_STATIC_STRING_IMPL("sourcemap"),
+        MAKE_STATIC_STRING_IMPL("strict-transport-security"),
+        MAKE_STATIC_STRING_IMPL("te"),
+        MAKE_STATIC_STRING_IMPL("timing-allow-origin"),
+        MAKE_STATIC_STRING_IMPL("trailer"),
+        MAKE_STATIC_STRING_IMPL("transfer-encoding"),
+        MAKE_STATIC_STRING_IMPL("upgrade"),
+        MAKE_STATIC_STRING_IMPL("upgrade-insecure-requests"),
+        MAKE_STATIC_STRING_IMPL("user-agent"),
+        MAKE_STATIC_STRING_IMPL("vary"),
+        MAKE_STATIC_STRING_IMPL("via"),
+        MAKE_STATIC_STRING_IMPL("x-content-type-options"),
+        MAKE_STATIC_STRING_IMPL("x-dns-prefetch-control"),
+        MAKE_STATIC_STRING_IMPL("x-frame-options"),
+        MAKE_STATIC_STRING_IMPL("x-sourcemap"),
+        MAKE_STATIC_STRING_IMPL("x-temp-tablet"),
+        MAKE_STATIC_STRING_IMPL("x-xss-protection"),
+    };
+
+    return staticHeaderNames[static_cast<size_t>(headerName)];
+}
+const WTF::String& httpHeaderNameDefaultCaseStringImpl(WebCore::HTTPHeaderName headerName)
+{
+    static const NeverDestroyed<String> staticHeaderNamesDefaultCase[] = {
+        MAKE_STATIC_STRING_IMPL("Accept"),
+        MAKE_STATIC_STRING_IMPL("Accept-Charset"),
+        MAKE_STATIC_STRING_IMPL("Accept-Encoding"),
+        MAKE_STATIC_STRING_IMPL("Accept-Language"),
+        MAKE_STATIC_STRING_IMPL("Accept-Ranges"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Credentials"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Headers"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Methods"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Allow-Origin"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Expose-Headers"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Max-Age"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Request-Headers"),
+        MAKE_STATIC_STRING_IMPL("Access-Control-Request-Method"),
+        MAKE_STATIC_STRING_IMPL("Age"),
+        MAKE_STATIC_STRING_IMPL("Authorization"),
+        MAKE_STATIC_STRING_IMPL("Cache-Control"),
+        MAKE_STATIC_STRING_IMPL("Connection"),
+        MAKE_STATIC_STRING_IMPL("Content-Disposition"),
+        MAKE_STATIC_STRING_IMPL("Content-Encoding"),
+        MAKE_STATIC_STRING_IMPL("Content-Language"),
+        MAKE_STATIC_STRING_IMPL("Content-Length"),
+        MAKE_STATIC_STRING_IMPL("Content-Location"),
+        MAKE_STATIC_STRING_IMPL("Content-Range"),
+        MAKE_STATIC_STRING_IMPL("Content-Security-Policy"),
+        MAKE_STATIC_STRING_IMPL("Content-Security-Policy-Report-Only"),
+        MAKE_STATIC_STRING_IMPL("Content-Type"),
+        MAKE_STATIC_STRING_IMPL("Cookie"),
+        MAKE_STATIC_STRING_IMPL("Cookie2"),
+        MAKE_STATIC_STRING_IMPL("Cross-Origin-Embedder-Policy"),
+        MAKE_STATIC_STRING_IMPL("Cross-Origin-Embedder-Policy-Report-Only"),
+        MAKE_STATIC_STRING_IMPL("Cross-Origin-Opener-Policy"),
+        MAKE_STATIC_STRING_IMPL("Cross-Origin-Opener-Policy-Report-Only"),
+        MAKE_STATIC_STRING_IMPL("Cross-Origin-Resource-Policy"),
+        MAKE_STATIC_STRING_IMPL("DNT"),
+        MAKE_STATIC_STRING_IMPL("Date"),
+        MAKE_STATIC_STRING_IMPL("Default-Style"),
+        MAKE_STATIC_STRING_IMPL("ETag"),
+        MAKE_STATIC_STRING_IMPL("Expect"),
+        MAKE_STATIC_STRING_IMPL("Expires"),
+        MAKE_STATIC_STRING_IMPL("Host"),
+        MAKE_STATIC_STRING_IMPL("Icy-Metaint"),
+        MAKE_STATIC_STRING_IMPL("Icy-Metadata"),
+        MAKE_STATIC_STRING_IMPL("If-Match"),
+        MAKE_STATIC_STRING_IMPL("If-Modified-Since"),
+        MAKE_STATIC_STRING_IMPL("If-None-Match"),
+        MAKE_STATIC_STRING_IMPL("If-Range"),
+        MAKE_STATIC_STRING_IMPL("If-Unmodified-Since"),
+        MAKE_STATIC_STRING_IMPL("Keep-Alive"),
+        MAKE_STATIC_STRING_IMPL("Last-Event-Id"),
+        MAKE_STATIC_STRING_IMPL("Last-Modified"),
+        MAKE_STATIC_STRING_IMPL("Link"),
+        MAKE_STATIC_STRING_IMPL("Location"),
+        MAKE_STATIC_STRING_IMPL("Origin"),
+        MAKE_STATIC_STRING_IMPL("Ping-From"),
+        MAKE_STATIC_STRING_IMPL("Ping-To"),
+        MAKE_STATIC_STRING_IMPL("Pragma"),
+        MAKE_STATIC_STRING_IMPL("Proxy-Authorization"),
+        MAKE_STATIC_STRING_IMPL("Purpose"),
+        MAKE_STATIC_STRING_IMPL("Range"),
+        MAKE_STATIC_STRING_IMPL("Referer"),
+        MAKE_STATIC_STRING_IMPL("Referrer-Policy"),
+        MAKE_STATIC_STRING_IMPL("Refresh"),
+        MAKE_STATIC_STRING_IMPL("Report-To"),
+        MAKE_STATIC_STRING_IMPL("Sec-Fetch-Dest"),
+        MAKE_STATIC_STRING_IMPL("Sec-Fetch-Mode"),
+        MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Accept"),
+        MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Extensions"),
+        MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Key"),
+        MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Protocol"),
+        MAKE_STATIC_STRING_IMPL("Sec-WebSocket-Version"),
+        MAKE_STATIC_STRING_IMPL("Server-Timing"),
+        MAKE_STATIC_STRING_IMPL("Service-Worker"),
+        MAKE_STATIC_STRING_IMPL("Service-Worker-Allowed"),
+        MAKE_STATIC_STRING_IMPL("Service-Worker-Navigation-Preload"),
+        MAKE_STATIC_STRING_IMPL("Set-Cookie"),
+        MAKE_STATIC_STRING_IMPL("Set-Cookie2"),
+        MAKE_STATIC_STRING_IMPL("Sourcemap"),
+        MAKE_STATIC_STRING_IMPL("Strict-Transport-Security"),
+        MAKE_STATIC_STRING_IMPL("TE"),
+        MAKE_STATIC_STRING_IMPL("Timing-Allow-Origin"),
+        MAKE_STATIC_STRING_IMPL("Trailer"),
+        MAKE_STATIC_STRING_IMPL("Transfer-Encoding"),
+        MAKE_STATIC_STRING_IMPL("Upgrade"),
+        MAKE_STATIC_STRING_IMPL("Upgrade-Insecure-Requests"),
+        MAKE_STATIC_STRING_IMPL("User-Agent"),
+        MAKE_STATIC_STRING_IMPL("Vary"),
+        MAKE_STATIC_STRING_IMPL("Via"),
+        MAKE_STATIC_STRING_IMPL("X-Content-Type-Options"),
+        MAKE_STATIC_STRING_IMPL("X-DNS-Prefetch-Control"),
+        MAKE_STATIC_STRING_IMPL("X-Frame-Options"),
+        MAKE_STATIC_STRING_IMPL("X-Sourcemap"),
+        MAKE_STATIC_STRING_IMPL("X-Temp-Tablet"),
+        MAKE_STATIC_STRING_IMPL("X-XSS-Protection"),
+    };
+
+    return staticHeaderNamesDefaultCase[static_cast<size_t>(headerName)];
+}
+
+}
diff --git a/src/bun.js/bindings/webcore/WebSocket.cpp b/src/bun.js/bindings/webcore/WebSocket.cpp
index 58b2d1049415be..e44742c079227e 100644
--- a/src/bun.js/bindings/webcore/WebSocket.cpp
+++ b/src/bun.js/bindings/webcore/WebSocket.cpp
@@ -1279,165 +1279,138 @@ void WebSocket::didFailWithErrorCode(int32_t code)
     }
     // invalid_response
     case 1: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Invalid response");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Invalid response"_s);
         break;
     }
     // expected_101_status_code
     case 2: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Expected 101 status code");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Expected 101 status code"_s);
         break;
     }
     // missing_upgrade_header
     case 3: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Missing upgrade header");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Missing upgrade header"_s);
         break;
     }
     // missing_connection_header
     case 4: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Missing connection header");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Missing connection header"_s);
         break;
     }
     // missing_websocket_accept_header
     case 5: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Missing websocket accept header");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Missing websocket accept header"_s);
         break;
     }
     // invalid_upgrade_header
     case 6: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Invalid upgrade header");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Invalid upgrade header"_s);
         break;
     }
     // invalid_connection_header
     case 7: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Invalid connection header");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Invalid connection header"_s);
         break;
     }
     // invalid_websocket_version
     case 8: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Invalid websocket version");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Invalid websocket version"_s);
         break;
     }
     // mismatch_websocket_accept_header
     case 9: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Mismatch websocket accept header");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Mismatch websocket accept header"_s);
         break;
     }
     // missing_client_protocol
     case 10: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Missing client protocol");
-        didReceiveClose(CleanStatus::Clean, 1002, message);
+        didReceiveClose(CleanStatus::Clean, 1002, "Missing client protocol"_s);
         break;
     }
     // mismatch_client_protocol
     case 11: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Mismatch client protocol");
-        didReceiveClose(CleanStatus::Clean, 1002, message);
+        didReceiveClose(CleanStatus::Clean, 1002, "Mismatch client protocol"_s);
         break;
     }
     // timeout
     case 12: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Timeout");
-        didReceiveClose(CleanStatus::Clean, 1013, message);
+        didReceiveClose(CleanStatus::Clean, 1013, "Timeout"_s);
         break;
     }
     // closed
     case 13: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Closed by client");
-        didReceiveClose(CleanStatus::Clean, 1000, message);
+        didReceiveClose(CleanStatus::Clean, 1000, "Closed by client"_s);
         break;
     }
     // failed_to_write
     case 14: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Failed to write");
-        didReceiveClose(CleanStatus::NotClean, 1006, message);
+        didReceiveClose(CleanStatus::NotClean, 1006, "Failed to write"_s);
         break;
     }
     // failed_to_connect
     case 15: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Failed to connect");
-        didReceiveClose(CleanStatus::NotClean, 1006, message, true);
+        didReceiveClose(CleanStatus::NotClean, 1006, "Failed to connect"_s, true);
         break;
     }
     // headers_too_large
     case 16: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Headers too large");
-        didReceiveClose(CleanStatus::NotClean, 1007, message);
+        didReceiveClose(CleanStatus::NotClean, 1007, "Headers too large"_s);
         break;
     }
     // ended
     case 17: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Connection ended");
-        didReceiveClose(CleanStatus::NotClean, 1006, message);
+        didReceiveClose(CleanStatus::NotClean, 1006, "Connection ended"_s);
         break;
     }
 
     // failed_to_allocate_memory
     case 18: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Failed to allocate memory");
-        didReceiveClose(CleanStatus::NotClean, 1001, message);
+        didReceiveClose(CleanStatus::NotClean, 1001, "Failed to allocate memory"_s);
         break;
     }
     // control_frame_is_fragmented
     case 19: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Protocol error - control frame is fragmented");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Protocol error - control frame is fragmented"_s);
         break;
     }
     // invalid_control_frame
     case 20: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Protocol error - invalid control frame");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Protocol error - invalid control frame"_s);
         break;
     }
     // compression_unsupported
     case 21: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Compression not implemented yet");
-        didReceiveClose(CleanStatus::Clean, 1011, message);
+        didReceiveClose(CleanStatus::Clean, 1011, "Compression not implemented yet"_s);
         break;
     }
     // unexpected_mask_from_server
     case 22: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Protocol error - unexpected mask from server");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Protocol error - unexpected mask from server"_s);
         break;
     }
     // expected_control_frame
     case 23: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Protocol error - expected control frame");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Protocol error - expected control frame"_s);
         break;
     }
     // unsupported_control_frame
     case 24: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Protocol error - unsupported control frame");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Protocol error - unsupported control frame"_s);
         break;
     }
     // unexpected_opcode
     case 25: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Protocol error - unexpected opcode");
-        didReceiveClose(CleanStatus::NotClean, 1002, message);
+        didReceiveClose(CleanStatus::NotClean, 1002, "Protocol error - unexpected opcode"_s);
         break;
     }
     // invalid_utf8
     case 26: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("Server sent invalid UTF8");
-        didReceiveClose(CleanStatus::NotClean, 1003, message);
+        didReceiveClose(CleanStatus::NotClean, 1003, "Server sent invalid UTF8"_s);
         break;
     }
     // tls_handshake_failed
     case 27: {
-        static NeverDestroyed<String> message = MAKE_STATIC_STRING_IMPL("TLS handshake failed");
-        didReceiveClose(CleanStatus::NotClean, 1015, message);
+        didReceiveClose(CleanStatus::NotClean, 1015, "TLS handshake failed"_s);
         break;
     }
     }
diff --git a/src/bun.js/bindings/workaround-missing-symbols.cpp b/src/bun.js/bindings/workaround-missing-symbols.cpp
index b09a388efbb913..b1fcc12a637fdc 100644
--- a/src/bun.js/bindings/workaround-missing-symbols.cpp
+++ b/src/bun.js/bindings/workaround-missing-symbols.cpp
@@ -65,6 +65,7 @@ extern "C" int kill(int pid, int sig)
 #include <stdarg.h>
 #include <errno.h>
 #include <math.h>
+#include <mutex>
 
 #ifndef _STAT_VER
 #if defined(__aarch64__)
@@ -150,18 +151,6 @@ int __wrap_fcntl(int fd, int cmd, ...)
 }
 
 typedef int (*fcntl64_func)(int fd, int cmd, ...);
-static fcntl64_func real_fcntl64 = NULL;
-
-static void init_real_fcntl64()
-{
-    if (!real_fcntl64) {
-        real_fcntl64 = (fcntl64_func)dlsym(RTLD_NEXT, "fcntl64");
-
-        if (!real_fcntl64) {
-            real_fcntl64 = (fcntl64_func)dlsym(RTLD_NEXT, "fcntl");
-        }
-    }
-}
 
 enum arg_type {
     NO_ARG,
@@ -217,7 +206,14 @@ extern "C" int __wrap_fcntl64(int fd, int cmd, ...)
     va_list ap;
     enum arg_type type = get_arg_type(cmd);
 
-    init_real_fcntl64();
+    static fcntl64_func real_fcntl64;
+    static std::once_flag real_fcntl64_initialized;
+    std::call_once(real_fcntl64_initialized, []() {
+        real_fcntl64 = (fcntl64_func)dlsym(RTLD_NEXT, "fcntl64");
+        if (!real_fcntl64) {
+            real_fcntl64 = (fcntl64_func)dlsym(RTLD_NEXT, "fcntl");
+        }
+    });
 
     switch (type) {
     case NO_ARG:
diff --git a/src/bun.js/event_loop.zig b/src/bun.js/event_loop.zig
index 6090bc6c9b0e82..ba3717e66a42a2 100644
--- a/src/bun.js/event_loop.zig
+++ b/src/bun.js/event_loop.zig
@@ -1487,38 +1487,36 @@ pub const EventLoop = struct {
 
     pub fn tick(this: *EventLoop) void {
         JSC.markBinding(@src());
-        {
-            this.entered_event_loop_count += 1;
-            this.debug.enter();
-            defer {
-                this.entered_event_loop_count -= 1;
-                this.debug.exit();
-            }
-
-            const ctx = this.virtual_machine;
-            this.tickConcurrent();
-            this.processGCTimer();
+        this.entered_event_loop_count += 1;
+        this.debug.enter();
+        defer {
+            this.entered_event_loop_count -= 1;
+            this.debug.exit();
+        }
 
-            const global = ctx.global;
-            const global_vm = ctx.jsc;
+        const ctx = this.virtual_machine;
+        this.tickConcurrent();
+        this.processGCTimer();
 
-            while (true) {
-                while (this.tickWithCount(ctx) > 0) : (this.global.handleRejectedPromises()) {
-                    this.tickConcurrent();
-                } else {
-                    this.drainMicrotasksWithGlobal(global, global_vm);
-                    this.tickConcurrent();
-                    if (this.tasks.count > 0) continue;
-                }
-                break;
-            }
+        const global = ctx.global;
+        const global_vm = ctx.jsc;
 
-            while (this.tickWithCount(ctx) > 0) {
+        while (true) {
+            while (this.tickWithCount(ctx) > 0) : (this.global.handleRejectedPromises()) {
                 this.tickConcurrent();
+            } else {
+                this.drainMicrotasksWithGlobal(global, global_vm);
+                this.tickConcurrent();
+                if (this.tasks.count > 0) continue;
             }
+            break;
+        }
 
-            this.global.handleRejectedPromises();
+        while (this.tickWithCount(ctx) > 0) {
+            this.tickConcurrent();
         }
+
+        this.global.handleRejectedPromises();
     }
 
     pub fn waitForPromise(this: *EventLoop, promise: JSC.AnyPromise) void {
diff --git a/src/bun.js/javascript.zig b/src/bun.js/javascript.zig
index 3b0ae317133dd6..c9c38a5f6845e7 100644
--- a/src/bun.js/javascript.zig
+++ b/src/bun.js/javascript.zig
@@ -429,10 +429,14 @@ pub export fn Bun__GlobalObject__hasIPC(global: *JSC.JSGlobalObject) bool {
 
 extern fn Bun__Process__queueNextTick1(*JSC.ZigGlobalObject, JSC.JSValue, JSC.JSValue) void;
 
-pub export fn Bun__Process__send(
+comptime {
+    const Bun__Process__send = JSC.toJSHostFunction(Bun__Process__send_);
+    @export(Bun__Process__send, .{ .name = "Bun__Process__send" });
+}
+pub fn Bun__Process__send_(
     globalObject: *JSGlobalObject,
     callFrame: *JSC.CallFrame,
-) callconv(JSC.conv) JSValue {
+) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
     var message, var handle, var options_, var callback = callFrame.arguments(4).ptr;
 
@@ -453,7 +457,7 @@ pub export fn Bun__Process__send(
     }
 
     const S = struct {
-        fn impl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+        fn impl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments_ = callframe.arguments(1).slice();
             const ex = arguments_[0];
             VirtualMachine.Process__emitErrorEvent(globalThis, ex);
@@ -1854,7 +1858,7 @@ pub const VirtualMachine = struct {
             },
         }
 
-        if (debugger != .unspecified) {
+        if (this.debugger != null) {
             this.bundler.options.minify_identifiers = false;
             this.bundler.options.minify_syntax = false;
             this.bundler.options.minify_whitespace = false;
@@ -1957,7 +1961,7 @@ pub const VirtualMachine = struct {
         return vm;
     }
 
-    pub fn initKit(opts: Options) anyerror!*VirtualMachine {
+    pub fn initBake(opts: Options) anyerror!*VirtualMachine {
         JSC.markBinding(@src());
         const allocator = opts.allocator;
         var log: *logger.Log = undefined;
@@ -3682,7 +3686,7 @@ pub const VirtualMachine = struct {
 
         if (error_instance != .zero and error_instance.isCell() and error_instance.jsType().canGet()) {
             inline for (extra_fields) |field| {
-                if (error_instance.getTruthyComptime(this.global, field)) |value| {
+                if (try error_instance.getTruthyComptime(this.global, field)) |value| {
                     const kind = value.jsType();
                     if (kind.isStringLike()) {
                         if (value.toStringOrNull(this.global)) |str| {
@@ -4367,9 +4371,6 @@ pub fn NewHotReloader(comptime Ctx: type, comptime EventLoopType: type, comptime
                 // const path = Fs.PathName.init(file_path);
                 const current_hash = hashes[event.index];
 
-                // if (this.verbose)
-                //     std.debug.print("onFileUpdate {s} ({s}, {})\n", .{ file_path, @tagName(kind), event.op });
-
                 switch (kind) {
                     .file => {
                         if (event.op.delete or event.op.rename) {
@@ -4546,16 +4547,14 @@ comptime {
     @export(string_allocation_limit, .{ .name = "Bun__stringSyntheticAllocationLimit" });
 }
 
-pub export fn Bun__setSyntheticAllocationLimitForTesting(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+pub fn Bun__setSyntheticAllocationLimitForTesting(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
     const args = callframe.arguments(1).slice();
     if (args.len < 1) {
-        globalObject.throwNotEnoughArguments("setSyntheticAllocationLimitForTesting", 1, args.len);
-        return JSValue.zero;
+        return globalObject.throwNotEnoughArguments("setSyntheticAllocationLimitForTesting", 1, args.len);
     }
 
     if (!args[0].isNumber()) {
-        globalObject.throwInvalidArguments("setSyntheticAllocationLimitForTesting expects a number", .{});
-        return JSValue.zero;
+        return globalObject.throwInvalidArguments2("setSyntheticAllocationLimitForTesting expects a number", .{});
     }
 
     const limit: usize = @intCast(@max(args[0].coerceToInt64(globalObject), 1024 * 1024));
diff --git a/src/bun.js/javascript_core_c_api.zig b/src/bun.js/javascript_core_c_api.zig
index 3bba44b331c7ee..18e3f199cd7aca 100644
--- a/src/bun.js/javascript_core_c_api.zig
+++ b/src/bun.js/javascript_core_c_api.zig
@@ -9,7 +9,7 @@ const std = @import("std");
 const cpp = @import("./bindings/bindings.zig");
 const generic = opaque {
     pub fn value(this: *const @This()) cpp.JSValue {
-        return @as(cpp.JSValue, @enumFromInt(@as(cpp.JSValue.Type, @bitCast(@intFromPtr(this)))));
+        return @as(cpp.JSValue, @enumFromInt(@as(cpp.JSValueReprInt, @bitCast(@intFromPtr(this)))));
     }
 
     pub inline fn bunVM(this: *@This()) *bun.JSC.VirtualMachine {
diff --git a/src/bun.js/module_loader.zig b/src/bun.js/module_loader.zig
index 2f378ec45a7ae7..b3a0b91da9e4ae 100644
--- a/src/bun.js/module_loader.zig
+++ b/src/bun.js/module_loader.zig
@@ -1767,7 +1767,7 @@ pub const ModuleLoader = struct {
                         .specifier = input_specifier,
                         .source_url = input_specifier.createIfDifferent(path.text),
                         .hash = 0,
-                        .jsvalue_for_export = parse_result.ast.parts.@"[0]"().stmts[0].data.s_expr.value.toJS(allocator, globalObject orelse jsc_vm.global, .{}) catch @panic("Unexpected JS error"),
+                        .jsvalue_for_export = parse_result.ast.parts.@"[0]"().stmts[0].data.s_expr.value.toJS(allocator, globalObject orelse jsc_vm.global) catch @panic("Unexpected JS error"),
                         .tag = .exports_object,
                     };
                 }
@@ -2472,7 +2472,7 @@ pub const ModuleLoader = struct {
                     return jsSyntheticModule(.@"bun:sql", specifier);
                 },
                 .@"bun:sqlite" => return jsSyntheticModule(.@"bun:sqlite", specifier),
-                .@"detect-libc" => return jsSyntheticModule(if (Environment.isLinux) .@"detect-libc/linux" else .@"detect-libc", specifier),
+                .@"detect-libc" => return jsSyntheticModule(if (!Environment.isLinux) .@"detect-libc" else if (!Environment.isMusl) .@"detect-libc/linux" else .@"detect-libc/musl", specifier),
                 .@"node:assert" => return jsSyntheticModule(.@"node:assert", specifier),
                 .@"node:assert/strict" => return jsSyntheticModule(.@"node:assert/strict", specifier),
                 .@"node:async_hooks" => return jsSyntheticModule(.@"node:async_hooks", specifier),
diff --git a/src/bun.js/modules/NodeModuleModule.cpp b/src/bun.js/modules/NodeModuleModule.cpp
index f412eb67859a81..e913e937b97608 100644
--- a/src/bun.js/modules/NodeModuleModule.cpp
+++ b/src/bun.js/modules/NodeModuleModule.cpp
@@ -354,9 +354,9 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName,
             }
         }
 
-        auto result = Bun__resolveSync(globalObject, JSC::JSValue::encode(moduleName),
-            JSValue::encode(fromValue), false);
         auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+        auto result = Bun__resolveSync(globalObject, JSC::JSValue::encode(moduleName), JSValue::encode(fromValue), false);
+        RETURN_IF_EXCEPTION(scope, {});
 
         if (!JSC::JSValue::decode(result).isString()) {
             JSC::throwException(globalObject, scope, JSC::JSValue::decode(result));
diff --git a/src/bun.js/node/node_cluster_binding.zig b/src/bun.js/node/node_cluster_binding.zig
index ef7596b4220ff8..08e3e50dab9fbf 100644
--- a/src/bun.js/node/node_cluster_binding.zig
+++ b/src/bun.js/node/node_cluster_binding.zig
@@ -12,7 +12,7 @@ extern fn Process__emitErrorEvent(global: *JSC.JSGlobalObject, value: JSC.JSValu
 
 pub var child_singleton: InternalMsgHolder = .{};
 
-pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     log("sendHelperChild", .{});
 
     const arguments = callframe.arguments(3).ptr;
@@ -50,7 +50,7 @@ pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFram
     const ipc_instance = vm.getIPCInstance().?;
 
     const S = struct {
-        fn impl(globalThis_: *JSC.JSGlobalObject, callframe_: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+        fn impl(globalThis_: *JSC.JSGlobalObject, callframe_: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments_ = callframe_.arguments(1).slice();
             const ex = arguments_[0];
             Process__emitErrorEvent(globalThis_, ex);
@@ -71,7 +71,7 @@ pub fn sendHelperChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFram
     return .true;
 }
 
-pub fn onInternalMessageChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn onInternalMessageChild(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     log("onInternalMessageChild", .{});
     const arguments = callframe.arguments(2).ptr;
     child_singleton.worker = JSC.Strong.create(arguments[0], globalThis);
@@ -172,7 +172,7 @@ pub const InternalMsgHolder = struct {
     }
 };
 
-pub fn sendHelperPrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn sendHelperPrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     log("sendHelperPrimary", .{});
 
     const arguments = callframe.arguments(4).ptr;
@@ -208,7 +208,7 @@ pub fn sendHelperPrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFr
     return .true;
 }
 
-pub fn onInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn onInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(3).ptr;
     const subprocess = arguments[0].as(bun.JSC.Subprocess).?;
     const ipc_data = subprocess.ipc() orelse return .undefined;
@@ -252,7 +252,7 @@ pub fn handleInternalMessagePrimary(globalThis: *JSC.JSGlobalObject, subprocess:
 
 extern fn Bun__setChannelRef(*JSC.JSGlobalObject, bool) void;
 
-pub fn setRef(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn setRef(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1).ptr;
 
     if (arguments.len == 0) {
diff --git a/src/bun.js/node/node_crypto_binding.zig b/src/bun.js/node/node_crypto_binding.zig
index 430f87f951fab2..3606afa9ce7d89 100644
--- a/src/bun.js/node/node_crypto_binding.zig
+++ b/src/bun.js/node/node_crypto_binding.zig
@@ -12,7 +12,7 @@ const EVP = Crypto.EVP;
 const PBKDF2 = EVP.PBKDF2;
 const JSValue = JSC.JSValue;
 const validators = @import("./util/validators.zig");
-fn randomInt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+fn randomInt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(2).slice();
 
     //min, max
@@ -41,13 +41,10 @@ fn randomInt(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSV
 fn pbkdf2(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(5);
 
-    const data = PBKDF2.fromJS(globalThis, arguments.slice(), true) orelse {
-        assert(globalThis.hasException());
-        return .zero;
-    };
+    const data = try PBKDF2.fromJS(globalThis, arguments.slice(), true);
 
     const job = PBKDF2.Job.create(JSC.VirtualMachine.get(), globalThis, &data);
     return job.promise.value();
@@ -56,13 +53,10 @@ fn pbkdf2(
 fn pbkdf2Sync(
     globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(5);
 
-    var data = PBKDF2.fromJS(globalThis, arguments.slice(), false) orelse {
-        assert(globalThis.hasException());
-        return .zero;
-    };
+    var data = try PBKDF2.fromJS(globalThis, arguments.slice(), false);
     defer data.deinit();
     var out_arraybuffer = JSC.JSValue.createBufferFromLength(globalThis, @intCast(data.length));
     if (out_arraybuffer == .zero or globalThis.hasException()) {
@@ -86,16 +80,12 @@ fn pbkdf2Sync(
     return out_arraybuffer;
 }
 
-const jsPbkdf2 = JSC.toJSHostFunction(pbkdf2);
-const jsPbkdf2Sync = JSC.toJSHostFunction(pbkdf2Sync);
-const jsRandomInt = JSC.toJSHostFunction(randomInt);
-
 pub fn createNodeCryptoBindingZig(global: *JSC.JSGlobalObject) JSC.JSValue {
     const crypto = JSC.JSValue.createEmptyObject(global, 3);
 
-    crypto.put(global, bun.String.init("pbkdf2"), JSC.JSFunction.create(global, "pbkdf2", jsPbkdf2, 5, .{}));
-    crypto.put(global, bun.String.init("pbkdf2Sync"), JSC.JSFunction.create(global, "pbkdf2Sync", jsPbkdf2Sync, 5, .{}));
-    crypto.put(global, bun.String.init("randomInt"), JSC.JSFunction.create(global, "randomInt", jsRandomInt, 2, .{}));
+    crypto.put(global, bun.String.init("pbkdf2"), JSC.JSFunction.create(global, "pbkdf2", pbkdf2, 5, .{}));
+    crypto.put(global, bun.String.init("pbkdf2Sync"), JSC.JSFunction.create(global, "pbkdf2Sync", pbkdf2Sync, 5, .{}));
+    crypto.put(global, bun.String.init("randomInt"), JSC.JSFunction.create(global, "randomInt", randomInt, 2, .{}));
 
     return crypto;
 }
diff --git a/src/bun.js/node/node_error_binding.zig b/src/bun.js/node/node_error_binding.zig
index 8c6de402a1471e..818725a0dd430d 100644
--- a/src/bun.js/node/node_error_binding.zig
+++ b/src/bun.js/node/node_error_binding.zig
@@ -14,9 +14,9 @@ pub const ERR_CHILD_CLOSED_BEFORE_REPLY = createSimpleError(createError, .ERR_CH
 
 fn createSimpleError(comptime createFn: anytype, comptime code: JSC.Node.ErrorCode, comptime message: string) JSC.JS2NativeFunctionType {
     const R = struct {
-        pub fn cbb(global: *JSC.JSGlobalObject) callconv(JSC.conv) JSC.JSValue {
+        pub fn cbb(global: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
             const S = struct {
-                fn cb(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+                fn cb(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                     _ = callframe;
                     return createFn(globalThis, code, message, .{});
                 }
diff --git a/src/bun.js/node/node_fs.zig b/src/bun.js/node/node_fs.zig
index 99a497e48e8a81..c5a69db2744129 100644
--- a/src/bun.js/node/node_fs.zig
+++ b/src/bun.js/node/node_fs.zig
@@ -1281,29 +1281,13 @@ pub const Arguments = struct {
             this.new_path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Rename {
-            const old_path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "oldPath must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Rename {
+            const old_path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("oldPath must be a string or TypedArray", .{});
             };
 
-            const new_path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "newPath must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const new_path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("newPath must be a string or TypedArray", .{});
             };
 
             return Rename{ .old_path = old_path, .new_path = new_path };
@@ -1328,17 +1312,9 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Truncate {
-            const path = PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Truncate {
+            const path = try PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
 
             const len: JSC.WebCore.Blob.SizeType = brk: {
@@ -1378,50 +1354,22 @@ pub const Arguments = struct {
             this.buffers.buffers.allocator = bun.default_allocator;
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Writev {
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Writev {
             const fd_value = arguments.nextEat() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
             };
 
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, fd_value, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, fd_value) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
-            const buffers = JSC.Node.VectorArrayBuffer.fromJS(
+            const buffers = try JSC.Node.VectorArrayBuffer.fromJS(
                 ctx,
                 arguments.protectEatNext() orelse {
-                    JSC.throwInvalidArguments("Expected an ArrayBufferView[]", .{}, ctx, exception);
-                    return null;
+                    return ctx.throwInvalidArguments2("Expected an ArrayBufferView[]", .{});
                 },
-                exception,
                 arguments.arena.allocator(),
-            ) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "buffers must be an array of TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            };
+            );
 
             var position: ?u52 = null;
 
@@ -1430,13 +1378,7 @@ pub const Arguments = struct {
                     if (pos_value.isNumber()) {
                         position = pos_value.to(u52);
                     } else {
-                        JSC.throwInvalidArguments(
-                            "position must be a number",
-                            .{},
-                            ctx,
-                            exception,
-                        );
-                        return null;
+                        return ctx.throwInvalidArguments2("position must be a number", .{});
                     }
                 }
             }
@@ -1469,50 +1411,22 @@ pub const Arguments = struct {
             this.buffers.buffers.allocator = bun.default_allocator;
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readv {
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Readv {
             const fd_value = arguments.nextEat() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
             };
 
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, fd_value, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, fd_value) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
-            const buffers = JSC.Node.VectorArrayBuffer.fromJS(
+            const buffers = try JSC.Node.VectorArrayBuffer.fromJS(
                 ctx,
                 arguments.protectEatNext() orelse {
-                    JSC.throwInvalidArguments("Expected an ArrayBufferView[]", .{}, ctx, exception);
-                    return null;
+                    return ctx.throwInvalidArguments2("Expected an ArrayBufferView[]", .{});
                 },
-                exception,
                 arguments.arena.allocator(),
-            ) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "buffers must be an array of TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            };
+            );
 
             var position: ?u52 = null;
 
@@ -1521,13 +1435,7 @@ pub const Arguments = struct {
                     if (pos_value.isNumber()) {
                         position = pos_value.to(u52);
                     } else {
-                        JSC.throwInvalidArguments(
-                            "position must be a number",
-                            .{},
-                            ctx,
-                            exception,
-                        );
-                        return null;
+                        return ctx.throwInvalidArguments2("position must be a number", .{});
                     }
                 }
             }
@@ -1552,33 +1460,15 @@ pub const Arguments = struct {
             _ = this;
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?FTruncate {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!FTruncate {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
             arguments.eat();
 
-            if (exception.* != null) return null;
-
             const len: JSC.WebCore.Blob.SizeType = brk: {
                 const len_value = arguments.next() orelse break :brk 0;
                 if (len_value.isNumber()) {
@@ -1610,57 +1500,34 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Chown {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Chown {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
+            errdefer path.deinit();
 
             const uid: uid_t = brk: {
                 const uid_value = arguments.next() orelse break :brk {
-                    if (exception.* == null) {
-                        JSC.throwInvalidArguments(
-                            "uid is required",
-                            .{},
-                            ctx,
-                            exception,
-                        );
-                    }
-                    return null;
+                    return ctx.throwInvalidArguments2("uid is required", .{});
                 };
 
                 arguments.eat();
                 if (!uid_value.isNumber()) {
                     _ = ctx.throwInvalidArgumentTypeValue("uid", "number", uid_value);
-                    return null;
+                    return error.JSError;
                 }
                 break :brk @as(uid_t, @intCast(uid_value.toInt32()));
             };
 
             const gid: gid_t = brk: {
                 const gid_value = arguments.next() orelse break :brk {
-                    if (exception.* == null) {
-                        JSC.throwInvalidArguments(
-                            "gid is required",
-                            .{},
-                            ctx,
-                            exception,
-                        );
-                    }
-                    return null;
+                    return ctx.throwInvalidArguments2("gid is required", .{});
                 };
 
                 arguments.eat();
                 if (!gid_value.isNumber()) {
                     _ = ctx.throwInvalidArgumentTypeValue("gid", "number", gid_value);
-                    return null;
+                    return error.JSError;
                 }
                 break :brk @as(gid_t, @intCast(gid_value.toInt32()));
             };
@@ -1678,42 +1545,16 @@ pub const Arguments = struct {
 
         pub fn toThreadSafe(_: *const @This()) void {}
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fchown {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Fchown {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
-            if (exception.* != null) return null;
-
             const uid: uid_t = brk: {
                 const uid_value = arguments.next() orelse break :brk {
-                    if (exception.* == null) {
-                        JSC.throwInvalidArguments(
-                            "uid is required",
-                            .{},
-                            ctx,
-                            exception,
-                        );
-                    }
-                    return null;
+                    return ctx.throwInvalidArguments2("uid is required", .{});
                 };
 
                 arguments.eat();
@@ -1722,15 +1563,7 @@ pub const Arguments = struct {
 
             const gid: gid_t = brk: {
                 const gid_value = arguments.next() orelse break :brk {
-                    if (exception.* == null) {
-                        JSC.throwInvalidArguments(
-                            "gid is required",
-                            .{},
-                            ctx,
-                            exception,
-                        );
-                    }
-                    return null;
+                    return ctx.throwInvalidArguments2("gid is required", .{});
                 };
 
                 arguments.eat();
@@ -1760,65 +1593,24 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Lutimes {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Lutimes {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
+            errdefer path.deinit();
 
             const atime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "atime is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "atime must be a number or a Date",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("atime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("atime must be a number or a Date", .{});
             };
 
             arguments.eat();
 
             const mtime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mtime is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mtime must be a number or a Date",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("mtime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("mtime must be a number or a Date", .{});
             };
 
             arguments.eat();
@@ -1843,39 +1635,16 @@ pub const Arguments = struct {
             this.path.deinitAndUnprotect();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Chmod {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Chmod {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
+            errdefer path.deinit();
 
-            const mode: Mode = JSC.Node.modeFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mode is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mode must be a string or integer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const mode: Mode = try JSC.Node.modeFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("mode is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("mode must be a string or integer", .{});
             };
 
             arguments.eat();
@@ -1892,52 +1661,19 @@ pub const Arguments = struct {
 
         pub fn toThreadSafe(_: *const @This()) void {}
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?FChmod {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!FChmod {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
-            if (exception.* != null) return null;
             arguments.eat();
 
-            const mode: Mode = JSC.Node.modeFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mode is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mode must be a string or integer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const mode: Mode = try JSC.Node.modeFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("mode is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("mode must be a string or integer", .{});
             };
 
             arguments.eat();
@@ -1965,20 +1701,11 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Stat {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Stat {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var throw_if_no_entry = true;
 
@@ -1988,17 +1715,11 @@ pub const Arguments = struct {
                         if (next_val.isCallable(ctx.vm())) break :brk false;
                         arguments.eat();
 
-                        if (next_val.getOptional(ctx, "throwIfNoEntry", bool) catch {
-                            path.deinit();
-                            return null;
-                        }) |throw_if_no_entry_val| {
+                        if (try next_val.getBooleanStrict(ctx, "throwIfNoEntry")) |throw_if_no_entry_val| {
                             throw_if_no_entry = throw_if_no_entry_val;
                         }
 
-                        if (next_val.getOptional(ctx, "bigint", bool) catch {
-                            path.deinit();
-                            return null;
-                        }) |big_int| {
+                        if (try next_val.getBooleanStrict(ctx, "bigint")) |big_int| {
                             break :brk big_int;
                         }
                     }
@@ -2006,8 +1727,6 @@ pub const Arguments = struct {
                 break :brk false;
             };
 
-            if (exception.* != null) return null;
-
             return Stat{ .path = path, .big_int = big_int, .throw_if_no_entry = throw_if_no_entry };
         }
     };
@@ -2020,38 +1739,20 @@ pub const Arguments = struct {
 
         pub fn toThreadSafe(_: *@This()) void {}
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fstat {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "file descriptor must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Fstat {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
-            if (exception.* != null) return null;
-
             const big_int = brk: {
                 if (arguments.next()) |next_val| {
                     if (next_val.isObject()) {
                         if (next_val.isCallable(ctx.vm())) break :brk false;
                         arguments.eat();
 
-                        if (next_val.getOptional(ctx, "bigint", bool) catch false) |big_int| {
+                        if (try next_val.getBooleanStrict(ctx, "bigint")) |big_int| {
                             break :brk big_int;
                         }
                     }
@@ -2059,8 +1760,6 @@ pub const Arguments = struct {
                 break :brk false;
             };
 
-            if (exception.* != null) return null;
-
             return Fstat{ .fd = fd, .big_int = big_int };
         }
     };
@@ -2086,35 +1785,15 @@ pub const Arguments = struct {
             this.new_path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Link {
-            const old_path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "oldPath must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Link {
+            const old_path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("oldPath must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
-            const new_path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "newPath must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const new_path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("newPath must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
             return Link{ .old_path = old_path, .new_path = new_path };
         }
     };
@@ -2150,35 +1829,15 @@ pub const Arguments = struct {
             this.new_path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Symlink {
-            const old_path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "target must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Symlink {
+            const old_path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("oldPath must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
-            const new_path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const new_path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("newPath must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
             const link_type: LinkType = if (!Environment.isWindows)
                 0
             else link_type: {
@@ -2198,15 +1857,8 @@ pub const Arguments = struct {
                         if (str.eqlComptime("dir")) break :link_type .dir;
                         if (str.eqlComptime("file")) break :link_type .file;
                         if (str.eqlComptime("junction")) break :link_type .junction;
-                        if (exception.* == null) {
-                            JSC.throwInvalidArguments(
-                                "Symlink type must be one of \"dir\", \"file\", or \"junction\". Received \"{}\"",
-                                .{str},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
+                        ctx.throwInvalidArguments("Symlink type must be one of \"dir\", \"file\", or \"junction\". Received \"{}\"", .{str});
+                        return error.JSError;
                     }
 
                     // not a string. fallthrough to auto detect.
@@ -2243,43 +1895,28 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readlink {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Readlink {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
+            errdefer path.deinit();
 
-            if (exception.* != null) return null;
             var encoding = Encoding.utf8;
             if (arguments.next()) |val| {
                 arguments.eat();
 
                 switch (val.jsType()) {
                     JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
-                        // Exception handled below.
-                        encoding = Encoding.assert(val, ctx, encoding) catch encoding;
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            // Exception handled below.
-                            encoding = getEncoding(val, ctx, encoding) catch encoding;
+                            encoding = try getEncoding(val, ctx, encoding);
                         }
                     },
                 }
             }
 
-            if (ctx.hasException()) {
-                path.deinit();
-                return null;
-            }
-
             return Readlink{ .path = path, .encoding = encoding };
         }
     };
@@ -2300,48 +1937,33 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Realpath {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Realpath {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
+            errdefer path.deinit();
 
-            if (exception.* != null) return null;
             var encoding = Encoding.utf8;
             if (arguments.next()) |val| {
                 arguments.eat();
 
                 switch (val.jsType()) {
                     JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
-                        // Exception handled below.
-                        encoding = Encoding.assert(val, ctx, encoding) catch encoding;
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            // Exception handled below.
-                            encoding = getEncoding(val, ctx, encoding) catch encoding;
+                            encoding = try getEncoding(val, ctx, encoding);
                         }
                     },
                 }
             }
 
-            if (ctx.hasException()) {
-                path.deinit();
-                return null;
-            }
-
             return Realpath{ .path = path, .encoding = encoding };
         }
     };
 
-    fn getEncoding(object: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) !Encoding {
+    fn getEncoding(object: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) bun.JSError!Encoding {
         if (object.fastGet(globalObject, .encoding)) |value| {
             return Encoding.assert(value, globalObject, default);
         }
@@ -2364,20 +1986,11 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Unlink {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Unlink {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             return Unlink{
                 .path = path,
@@ -2408,20 +2021,11 @@ pub const Arguments = struct {
             this.path.deinit();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?RmDir {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!RmDir {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var recursive = false;
             var force = false;
@@ -2429,17 +2033,11 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 if (val.isObject()) {
-                    if (val.getOptional(ctx, "recursive", bool) catch {
-                        path.deinit();
-                        return null;
-                    }) |boolean| {
+                    if (try val.getBooleanStrict(ctx, "recursive")) |boolean| {
                         recursive = boolean;
                     }
 
-                    if (val.getOptional(ctx, "force", bool) catch {
-                        path.deinit();
-                        return null;
-                    }) |boolean| {
+                    if (try val.getBooleanStrict(ctx, "force")) |boolean| {
                         force = boolean;
                     }
                 }
@@ -2479,20 +2077,11 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: *JSC.JSGlobalObject, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Mkdir {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: *JSC.JSGlobalObject, arguments: *ArgumentsSlice) bun.JSError!Mkdir {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var recursive = false;
             var mode: Mode = 0o777;
@@ -2501,16 +2090,12 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 if (val.isObject()) {
-                    if (val.getOptional(ctx, "recursive", bool) catch {
-                        path.deinit();
-                        return null;
-                    }) |boolean| {
+                    if (try val.getBooleanStrict(ctx, "recursive")) |boolean| {
                         recursive = boolean;
                     }
 
                     if (val.get(ctx, "mode")) |mode_| {
-                        mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse mode;
-                        if (exception.* != null) return null;
+                        mode = try JSC.Node.modeFromJS(ctx, mode_) orelse mode;
                     }
                 }
             }
@@ -2539,22 +2124,13 @@ pub const Arguments = struct {
             this.prefix.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?MkdirTemp {
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!MkdirTemp {
             const prefix_value = arguments.next() orelse return MkdirTemp{};
 
             const prefix = StringOrBuffer.fromJS(ctx, bun.default_allocator, prefix_value) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "prefix must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("prefix must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer prefix.deinit();
 
             arguments.eat();
 
@@ -2565,22 +2141,16 @@ pub const Arguments = struct {
 
                 switch (val.jsType()) {
                     JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
-                        // exception handled below.
-                        encoding = Encoding.assert(val, ctx, encoding) catch encoding;
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            encoding = getEncoding(val, ctx, encoding) catch encoding;
+                            encoding = try getEncoding(val, ctx, encoding);
                         }
                     },
                 }
             }
 
-            if (ctx.hasException()) {
-                prefix.deinit();
-                return null;
-            }
-
             return MkdirTemp{
                 .prefix = prefix,
                 .encoding = encoding,
@@ -2616,20 +2186,11 @@ pub const Arguments = struct {
             };
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Readdir {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Readdir {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var encoding = Encoding.utf8;
             var with_file_types = false;
@@ -2639,32 +2200,21 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 switch (val.jsType()) {
-                    JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject => {
-                        encoding = Encoding.assert(val, ctx, encoding) catch {
-                            path.deinit();
-                            return null;
-                        };
+                    .String,
+                    .StringObject,
+                    .DerivedStringObject,
+                    => {
+                        encoding = try Encoding.assert(val, ctx, encoding);
                     },
                     else => {
                         if (val.isObject()) {
-                            encoding = getEncoding(val, ctx, encoding) catch encoding;
-
-                            if (ctx.hasException()) {
-                                path.deinit();
-                                return null;
-                            }
+                            encoding = try getEncoding(val, ctx, encoding);
 
-                            if (val.getOptional(ctx, "recursive", bool) catch {
-                                path.deinit();
-                                return null;
-                            }) |recursive_| {
+                            if (try val.getBooleanStrict(ctx, "recursive")) |recursive_| {
                                 recursive = recursive_;
                             }
 
-                            if (val.getOptional(ctx, "withFileTypes", bool) catch {
-                                path.deinit();
-                                return null;
-                            }) |with_file_types_| {
+                            if (try val.getBooleanStrict(ctx, "withFileTypes")) |with_file_types_| {
                                 with_file_types = with_file_types_;
                             }
                         }
@@ -2687,31 +2237,13 @@ pub const Arguments = struct {
         pub fn deinit(_: Close) void {}
         pub fn toThreadSafe(_: Close) void {}
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Close {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "File descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "fd must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Close {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
 
-            if (exception.* != null) return null;
-
             return Close{ .fd = fd };
         }
     };
@@ -2733,20 +2265,11 @@ pub const Arguments = struct {
             this.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Open {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Open {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var flags = FileSystemFlags.r;
             var mode: Mode = default_permission;
@@ -2755,31 +2278,25 @@ pub const Arguments = struct {
                 arguments.eat();
 
                 if (val.isObject()) {
-                    if (val.getTruthy(ctx, "flags")) |flags_| {
-                        flags = FileSystemFlags.fromJS(ctx, flags_, exception) orelse flags;
-                        if (exception.* != null) return null;
+                    if (try val.getTruthy(ctx, "flags")) |flags_| {
+                        flags = try FileSystemFlags.fromJS(ctx, flags_) orelse flags;
                     }
 
-                    if (val.getTruthy(ctx, "mode")) |mode_| {
-                        mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse mode;
-                        if (exception.* != null) return null;
+                    if (try val.getTruthy(ctx, "mode")) |mode_| {
+                        mode = try JSC.Node.modeFromJS(ctx, mode_) orelse mode;
                     }
-                } else if (!val.isEmpty()) {
+                } else if (val != .zero) {
                     if (!val.isUndefinedOrNull()) {
                         // error is handled below
-                        flags = FileSystemFlags.fromJS(ctx, val, exception) orelse flags;
-                        if (exception.* != null) return null;
+                        flags = try FileSystemFlags.fromJS(ctx, val) orelse flags;
                     }
 
                     if (arguments.nextEat()) |next| {
-                        mode = JSC.Node.modeFromJS(ctx, next, exception) orelse mode;
-                        if (exception.* != null) return null;
+                        mode = try JSC.Node.modeFromJS(ctx, next) orelse mode;
                     }
                 }
             }
 
-            if (exception.* != null) return null;
-
             return Open{
                 .path = path,
                 .flags = flags,
@@ -2808,78 +2325,27 @@ pub const Arguments = struct {
             _ = self;
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Futimes {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "File descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "fd must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Futimes {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
             arguments.eat();
-            if (exception.* != null) return null;
 
             const atime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "atime is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "atime must be a number, Date or string",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("atime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("atime must be a number or a Date", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             const mtime = JSC.Node.timeLikeFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mtime is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "mtime must be a number, Date or string",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("mtime is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("mtime must be a number or a Date", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             return Futimes{
                 .fd = fd,
@@ -2934,54 +2400,24 @@ pub const Arguments = struct {
             self.buffer.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Write {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "File descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "fd must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Write {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
-
             arguments.eat();
 
-            if (exception.* != null) return null;
-
             const buffer_value = arguments.next();
             const buffer = StringOrBuffer.fromJS(ctx, bun.default_allocator, buffer_value orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "data is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("data is required", .{});
             }) orelse {
-                if (exception.* == null) {
-                    _ = ctx.throwInvalidArgumentTypeValue("buffer", "string or TypedArray", buffer_value.?);
-                }
-                return null;
+                _ = ctx.throwInvalidArgumentTypeValue("buffer", "string or TypedArray", buffer_value.?);
+                return error.JSError;
             };
-            if (exception.* != null) return null;
             if (buffer_value.?.isString() and !buffer_value.?.isStringLiteral()) {
                 _ = ctx.throwInvalidArgumentTypeValue("buffer", "string or TypedArray", buffer_value.?);
-                return null;
+                return error.JSError;
             }
 
             var args = Write{
@@ -2992,6 +2428,7 @@ pub const Arguments = struct {
                     inline else => Encoding.utf8,
                 },
             };
+            errdefer args.deinit();
 
             arguments.eat();
 
@@ -3009,10 +2446,7 @@ pub const Arguments = struct {
                             }
 
                             if (current.isString()) {
-                                args.encoding = Encoding.assert(current, ctx, args.encoding) catch {
-                                    args.deinit();
-                                    return null;
-                                };
+                                args.encoding = try Encoding.assert(current, ctx, args.encoding);
                                 arguments.eat();
                             }
                         },
@@ -3061,58 +2495,21 @@ pub const Arguments = struct {
             this.buffer.buffer.value.unprotect();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Read {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "File descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "fd must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Read {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
-
             arguments.eat();
 
-            if (exception.* != null) return null;
-
             const buffer_value = arguments.next();
-            const buffer: Buffer = Buffer.fromJS(ctx, buffer_value orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "buffer is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "buffer must be a TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const buffer = Buffer.fromJS(ctx, buffer_value orelse {
+                return ctx.throwInvalidArguments2("buffer is required", .{});
+            }) orelse {
+                _ = ctx.throwInvalidArgumentTypeValue("buffer", "TypedArray", buffer_value.?);
+                return error.JSError;
             };
-
-            if (exception.* != null) return null;
-
             arguments.eat();
 
             var args = Read{
@@ -3127,8 +2524,8 @@ pub const Arguments = struct {
                     args.offset = current.to(u52);
 
                     if (arguments.remaining.len < 1) {
-                        JSC.throwInvalidArguments("length is required", .{}, ctx, exception);
-                        return null;
+                        ctx.throwInvalidArguments("length is required", .{});
+                        return error.JSError;
                     }
 
                     const arg_length = arguments.next().?;
@@ -3146,20 +2543,20 @@ pub const Arguments = struct {
                         }
                     }
                 } else if (current.isObject()) {
-                    if (current.getTruthy(ctx, "offset")) |num| {
+                    if (try current.getTruthy(ctx, "offset")) |num| {
                         if (num.isNumber() or num.isBigInt()) {
                             args.offset = num.to(u52);
                         }
                     }
 
-                    if (current.getTruthy(ctx, "length")) |num| {
+                    if (try current.getTruthy(ctx, "length")) |num| {
                         if (num.isNumber() or num.isBigInt()) {
                             args.length = num.to(u52);
                         }
                         defined_length = true;
                     }
 
-                    if (current.getTruthy(ctx, "position")) |num| {
+                    if (try current.getTruthy(ctx, "position")) |num| {
                         if (num.isNumber() or num.isBigInt()) {
                             args.position = num.to(i52);
                         }
@@ -3170,7 +2567,7 @@ pub const Arguments = struct {
             if (defined_length and args.length > 0 and buffer.slice().len == 0) {
                 var formatter = bun.JSC.ConsoleObject.Formatter{ .globalThis = ctx };
                 ctx.ERR_INVALID_ARG_VALUE("The argument 'buffer' is empty and cannot be written. Received {}", .{buffer_value.?.toFmt(&formatter)}).throw();
-                return null;
+                return error.JSError;
             }
 
             return args;
@@ -3204,20 +2601,11 @@ pub const Arguments = struct {
             self.path.toThreadSafe();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?ReadFile {
-            const path = PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or a file descriptor",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!ReadFile {
+            const path = try PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or a file descriptor", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var encoding = Encoding.buffer;
             var flag = FileSystemFlags.r;
@@ -3225,36 +2613,15 @@ pub const Arguments = struct {
             if (arguments.next()) |arg| {
                 arguments.eat();
                 if (arg.isString()) {
-                    encoding = Encoding.assert(arg, ctx, encoding) catch {
-                        path.deinit();
-                        return null;
-                    };
+                    encoding = try Encoding.assert(arg, ctx, encoding);
                 } else if (arg.isObject()) {
-                    encoding = getEncoding(arg, ctx, encoding) catch encoding;
-
-                    if (ctx.hasException()) {
-                        path.deinit();
-                        return null;
-                    }
+                    encoding = try getEncoding(arg, ctx, encoding);
 
-                    if (arg.getTruthy(ctx, "flag")) |flag_| {
-                        flag = FileSystemFlags.fromJS(ctx, flag_, exception) orelse {
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid flag",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
+                    if (try arg.getTruthy(ctx, "flag")) |flag_| {
+                        flag = try FileSystemFlags.fromJS(ctx, flag_) orelse {
+                            return ctx.throwInvalidArguments2("Invalid flag", .{});
                         };
                     }
-
-                    if (ctx.hasException()) {
-                        path.deinit();
-                        return null;
-                    }
                 }
             }
 
@@ -3295,32 +2662,14 @@ pub const Arguments = struct {
             self.data.deinitAndUnprotect();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?WriteFile {
-            const file = PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or a file descriptor",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!WriteFile {
+            const path = try PathOrFileDescriptor.fromJS(ctx, arguments, bun.default_allocator) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or a file descriptor", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             const data_value = arguments.nextEat() orelse {
-                defer file.deinit();
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "data is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+                return ctx.throwInvalidArguments2("data is required", .{});
             };
 
             var encoding = Encoding.buffer;
@@ -3334,68 +2683,31 @@ pub const Arguments = struct {
             if (arguments.next()) |arg| {
                 arguments.eat();
                 if (arg.isString()) {
-                    encoding = Encoding.assert(arg, ctx, encoding) catch encoding;
+                    encoding = try Encoding.assert(arg, ctx, encoding);
                 } else if (arg.isObject()) {
-                    encoding = getEncoding(arg, ctx, encoding) catch encoding;
-
-                    if (ctx.hasException()) {
-                        file.deinit();
-                        return null;
-                    }
+                    encoding = try getEncoding(arg, ctx, encoding);
 
-                    if (arg.getTruthy(ctx, "flag")) |flag_| {
-                        flag = FileSystemFlags.fromJS(ctx, flag_, exception) orelse {
-                            defer file.deinit();
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid flag",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
+                    if (try arg.getTruthy(ctx, "flag")) |flag_| {
+                        flag = try FileSystemFlags.fromJS(ctx, flag_) orelse {
+                            return ctx.throwInvalidArguments2("Invalid flag", .{});
                         };
                     }
 
-                    if (arg.getTruthy(ctx, "mode")) |mode_| {
-                        mode = JSC.Node.modeFromJS(ctx, mode_, exception) orelse {
-                            defer file.deinit();
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "Invalid flag",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
+                    if (try arg.getTruthy(ctx, "mode")) |mode_| {
+                        mode = try JSC.Node.modeFromJS(ctx, mode_) orelse {
+                            return ctx.throwInvalidArguments2("Invalid mode", .{});
                         };
                     }
                 }
             }
 
-            if (ctx.hasException()) {
-                file.deinit();
-                return null;
-            }
-
-            const data = StringOrBuffer.fromJSWithEncodingMaybeAsync(ctx, bun.default_allocator, data_value, encoding, arguments.will_be_async) orelse {
-                defer file.deinit();
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "data must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const data = try StringOrBuffer.fromJSWithEncodingMaybeAsync(ctx, bun.default_allocator, data_value, encoding, arguments.will_be_async) orelse {
+                return ctx.throwInvalidArguments2("data must be a string or TypedArray", .{});
             };
 
             // Note: Signal is not implemented
             return WriteFile{
-                .file = file,
+                .file = path,
                 .encoding = encoding,
                 .flag = flag,
                 .mode = mode,
@@ -3418,20 +2730,11 @@ pub const Arguments = struct {
             self.path.deinit();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?OpenDir {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or a file descriptor",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!OpenDir {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var encoding = Encoding.buffer;
             var buffer_size: c_int = 32;
@@ -3445,33 +2748,15 @@ pub const Arguments = struct {
                         encoding = encoding_;
                     }
 
-                    if (ctx.hasException()) {
-                        path.deinit();
-                        return null;
-                    }
-
                     if (arg.get(ctx, "bufferSize")) |buffer_size_| {
                         buffer_size = buffer_size_.toInt32();
                         if (buffer_size < 0) {
-                            if (exception.* == null) {
-                                JSC.throwInvalidArguments(
-                                    "bufferSize must be > 0",
-                                    .{},
-                                    ctx,
-                                    exception,
-                                );
-                            }
-                            return null;
+                            return ctx.throwInvalidArguments2("bufferSize must be > 0", .{});
                         }
                     }
                 }
             }
 
-            if (ctx.hasException()) {
-                path.deinit();
-                return null;
-            }
-
             return OpenDir{
                 .path = path,
                 .encoding = encoding,
@@ -3501,9 +2786,9 @@ pub const Arguments = struct {
             }
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Exists {
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Exists {
             return Exists{
-                .path = PathLike.fromJS(ctx, arguments, exception),
+                .path = try PathLike.fromJS(ctx, arguments),
             };
         }
     };
@@ -3524,36 +2809,19 @@ pub const Arguments = struct {
             this.path.deinitAndUnprotect();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Access {
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "path must be a string or buffer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Access {
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("path must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer path.deinit();
 
             var mode = FileSystemFlags.r;
 
             if (arguments.next()) |arg| {
                 arguments.eat();
                 if (arg.isString()) {
-                    mode = FileSystemFlags.fromJS(ctx, arg, exception) orelse {
-                        if (exception.* == null) {
-                            JSC.throwInvalidArguments(
-                                "Invalid mode",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                        }
-                        return null;
+                    mode = try FileSystemFlags.fromJS(ctx, arg) orelse {
+                        return ctx.throwInvalidArguments2("Invalid mode", .{});
                     };
                 }
             }
@@ -3573,30 +2841,13 @@ pub const Arguments = struct {
             _ = self;
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?FdataSync {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "File descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "fd must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!FdataSync {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             return FdataSync{ .fd = fd };
         }
@@ -3622,36 +2873,16 @@ pub const Arguments = struct {
             this.dest.deinitAndUnprotect();
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?CopyFile {
-            const src = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "src must be a string or buffer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!CopyFile {
+            const src = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("src must be a string or TypedArray", .{});
             };
+            errdefer src.deinit();
 
-            if (exception.* != null) return null;
-
-            const dest = PathLike.fromJS(ctx, arguments, exception) orelse {
-                src.deinit();
-
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "dest must be a string or buffer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const dest = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("dest must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer dest.deinit();
 
             var mode: i32 = 0;
             if (arguments.next()) |arg| {
@@ -3689,35 +2920,16 @@ pub const Arguments = struct {
             }
         }
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Cp {
-            const src = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "src must be a string or buffer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Cp {
+            const src = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("src must be a string or TypedArray", .{});
             };
+            errdefer src.deinit();
 
-            if (exception.* != null) return null;
-
-            const dest = PathLike.fromJS(ctx, arguments, exception) orelse {
-                defer src.deinit();
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "dest must be a string or buffer",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const dest = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("dest must be a string or TypedArray", .{});
             };
-
-            if (exception.* != null) return null;
+            errdefer dest.deinit();
 
             var recursive: bool = false;
             var errorOnExist: bool = false;
@@ -3783,30 +2995,13 @@ pub const Arguments = struct {
         pub fn deinit(_: Fsync) void {}
         pub fn toThreadSafe(_: *const @This()) void {}
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fsync {
-            const fd = JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "File descriptor is required",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
-            }, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "fd must be a number",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Fsync {
+            const fd = try JSC.Node.fileDescriptorFromJS(ctx, arguments.next() orelse {
+                return ctx.throwInvalidArguments2("file descriptor is required", .{});
+            }) orelse {
+                return ctx.throwInvalidArguments2("file descriptor must be a number", .{});
             };
-
-            if (exception.* != null) return null;
+            arguments.eat();
 
             return Fsync{ .fd = fd };
         }
@@ -3964,6 +3159,7 @@ const Return = struct {
     pub const ReadFile = StringOrBuffer;
     pub const ReadFileWithOptions = union(enum) {
         string: string,
+        transcoded_string: bun.String,
         buffer: JSC.Node.Buffer,
         null_terminated: [:0]const u8,
     };
@@ -4001,11 +3197,7 @@ pub const NodeFS = struct {
 
     pub fn access(this: *NodeFS, args: Arguments.Access, comptime _: Flavor) Maybe(Return.Access) {
         const path = args.path.sliceZ(&this.sync_error_buf);
-        if (Environment.isWindows) {
-            return Syscall.access(path, @intFromEnum(args.mode));
-        }
-        const rc = Syscall.system.access(path, @intFromEnum(args.mode));
-        return Maybe(Return.Access).errnoSysP(rc, .access, path) orelse Maybe(Return.Access).success;
+        return Syscall.access(path, @intFromEnum(args.mode));
     }
 
     pub fn appendFile(this: *NodeFS, args: Arguments.AppendFile, comptime flavor: Flavor) Maybe(Return.AppendFile) {
@@ -5524,6 +4716,19 @@ pub const NodeFS = struct {
                         .buffer = ret.result.buffer,
                     },
                 },
+                .transcoded_string => |str| {
+                    if (str.tag == .Dead) {
+                        return .{ .err = Syscall.Error.fromCode(.NOMEM, .read).withPathLike(args.path) };
+                    }
+
+                    return .{
+                        .result = .{
+                            .string = .{
+                                .underlying = str,
+                            },
+                        },
+                    };
+                },
                 .string => brk: {
                     const str = bun.SliceWithUnderlyingString.transcodeFromOwnedSlice(@constCast(ret.result.string), args.encoding);
 
@@ -5538,7 +4743,7 @@ pub const NodeFS = struct {
         };
     }
 
-    pub fn readFileWithOptions(this: *NodeFS, args: Arguments.ReadFile, comptime _: Flavor, comptime string_type: StringType) Maybe(Return.ReadFileWithOptions) {
+    pub fn readFileWithOptions(this: *NodeFS, args: Arguments.ReadFile, comptime flavor: Flavor, comptime string_type: StringType) Maybe(Return.ReadFileWithOptions) {
         var path: [:0]const u8 = undefined;
         const fd_maybe_windows: FileDescriptor = switch (args.path) {
             .path => brk: {
@@ -5602,6 +4807,107 @@ pub const NodeFS = struct {
                 _ = Syscall.close(fd);
         }
 
+        // Only used in DOMFormData
+        if (args.offset > 0) {
+            _ = Syscall.setFileOffset(fd, args.offset);
+        }
+
+        var did_succeed = false;
+        var total: usize = 0;
+        var async_stack_buffer: [if (flavor == .sync) 0 else 256 * 1024]u8 = undefined;
+
+        // --- Optimization: attempt to read up to 256 KB before calling stat()
+        // If we manage to read the entire file, we don't need to call stat() at all.
+        // This will make it slightly slower to read e.g. 512 KB files, but usually the OS won't return a full 512 KB in one read anyway.
+        const temporary_read_buffer_before_stat_call = brk: {
+            const temporary_read_buffer = temporary_read_buffer: {
+                var temporary_read_buffer: []u8 = &async_stack_buffer;
+
+                if (comptime flavor == .sync) {
+                    if (this.vm) |vm| {
+                        temporary_read_buffer = vm.rareData().pipeReadBuffer();
+                    }
+                }
+
+                var available = temporary_read_buffer;
+                while (available.len > 0) {
+                    switch (Syscall.read(fd, available)) {
+                        .err => |err| return .{
+                            .err = err,
+                        },
+                        .result => |amt| {
+                            if (amt == 0) {
+                                did_succeed = true;
+                                break;
+                            }
+                            total += amt;
+                            available = available[amt..];
+                        },
+                    }
+                }
+                break :temporary_read_buffer temporary_read_buffer[0..total];
+            };
+
+            if (did_succeed) {
+                switch (args.encoding) {
+                    .buffer => {
+                        if (comptime flavor == .sync and string_type == .default) {
+                            if (this.vm) |vm| {
+                                // Attempt to create the buffer in JSC's heap.
+                                // This avoids creating a WastefulTypedArray.
+                                const array_buffer = JSC.ArrayBuffer.createBuffer(vm.global, temporary_read_buffer);
+                                array_buffer.ensureStillAlive();
+                                return .{
+                                    .result = .{
+                                        .buffer = JSC.MarkedArrayBuffer{
+                                            .buffer = array_buffer.asArrayBuffer(vm.global) orelse {
+                                                // This case shouldn't really happen.
+                                                return .{
+                                                    .err = Syscall.Error.fromCode(.NOMEM, .read).withPathLike(args.path),
+                                                };
+                                            },
+                                        },
+                                    },
+                                };
+                            }
+                        }
+
+                        return .{
+                            .result = .{
+                                .buffer = Buffer.fromBytes(
+                                    bun.default_allocator.dupe(u8, temporary_read_buffer) catch return .{
+                                        .err = Syscall.Error.fromCode(.NOMEM, .read).withPathLike(args.path),
+                                    },
+                                    bun.default_allocator,
+                                    .Uint8Array,
+                                ),
+                            },
+                        };
+                    },
+                    else => {
+                        if (comptime string_type == .default) {
+                            return .{
+                                .result = .{
+                                    .transcoded_string = JSC.WebCore.Encoder.toWTFString(temporary_read_buffer, args.encoding),
+                                },
+                            };
+                        } else {
+                            return .{
+                                .result = .{
+                                    .null_terminated = bun.default_allocator.dupeZ(u8, temporary_read_buffer) catch return .{
+                                        .err = Syscall.Error.fromCode(.NOMEM, .read).withPathLike(args.path),
+                                    },
+                                },
+                            };
+                        }
+                    },
+                }
+            }
+
+            break :brk temporary_read_buffer;
+        };
+        // ----------------------------
+
         const stat_ = switch (Syscall.fstat(fd)) {
             .err => |err| return .{
                 .err = err,
@@ -5609,10 +4915,6 @@ pub const NodeFS = struct {
             .result => |stat_| stat_,
         };
 
-        // Only used in DOMFormData
-        if (args.offset > 0) {
-            _ = Syscall.setFileOffset(fd, args.offset);
-        }
         // For certain files, the size might be 0 but the file might still have contents.
         // https://github.com/oven-sh/bun/issues/1220
         const max_size = args.max_size orelse std.math.maxInt(JSC.WebCore.Blob.SizeType);
@@ -5626,6 +4928,7 @@ pub const NodeFS = struct {
                     // Only used in DOMFormData
                     max_size,
                 ),
+                @as(i64, @intCast(total)),
                 0,
             ),
         ) + @intFromBool(comptime string_type == .null_terminated);
@@ -5639,14 +4942,23 @@ pub const NodeFS = struct {
             }
         }
 
-        var did_succeed = false;
         var buf = std.ArrayList(u8).init(bun.default_allocator);
         defer if (!did_succeed) buf.clearAndFree();
-        buf.ensureTotalCapacityPrecise(size + 16) catch return .{
+        buf.ensureTotalCapacityPrecise(
+            @min(
+                @max(temporary_read_buffer_before_stat_call.len, size) + 16,
+                max_size,
+                1024 * 1024 * 1024 * 8,
+            ),
+        ) catch return .{
             .err = Syscall.Error.fromCode(.NOMEM, .read).withPathLike(args.path),
         };
+        if (temporary_read_buffer_before_stat_call.len > 0) {
+            buf.appendSlice(temporary_read_buffer_before_stat_call) catch return .{
+                .err = Syscall.Error.fromCode(.NOMEM, .read).withPathLike(args.path),
+            };
+        }
         buf.expandToCapacity();
-        var total: usize = 0;
 
         while (total < size) {
             switch (Syscall.read(fd, buf.items.ptr[total..@min(buf.capacity, max_size)])) {
@@ -5804,16 +5116,15 @@ pub const NodeFS = struct {
                         // on mac, it's relatively positioned
                         0
                     else brk: {
-                        // on linux, it's absolutely positioned
-                        const pos = bun.sys.system.lseek(
-                            fd.cast(),
+                        // on linux, it's absolutely positione
+
+                        switch (Syscall.lseek(
+                            fd,
                             @as(std.posix.off_t, @intCast(0)),
                             std.os.linux.SEEK.CUR,
-                        );
-
-                        switch (bun.sys.getErrno(pos)) {
-                            .SUCCESS => break :brk @as(usize, @intCast(pos)),
-                            else => break :preallocate,
+                        )) {
+                            .err => break :preallocate,
+                            .result => |pos| break :brk @as(usize, @intCast(pos)),
                         }
                     };
 
diff --git a/src/bun.js/node/node_fs_binding.zig b/src/bun.js/node/node_fs_binding.zig
index c0dc296e5d45e7..169c356f676b2e 100644
--- a/src/bun.js/node/node_fs_binding.zig
+++ b/src/bun.js/node/node_fs_binding.zig
@@ -14,7 +14,7 @@ const NodeFSFunction = fn (
     this: *JSC.Node.NodeJSFS,
     globalObject: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSC.JSValue;
+) bun.JSError!JSC.JSValue;
 
 const NodeFSFunctionEnum = std.meta.DeclEnum(JSC.Node.NodeFS);
 
@@ -34,33 +34,21 @@ fn callSync(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
             this: *JSC.Node.NodeJSFS,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
-            var exceptionref: JSC.C.JSValueRef = null;
-
+        ) bun.JSError!JSC.JSValue {
             var arguments = callframe.arguments(8);
 
             var slice = ArgumentsSlice.init(globalObject.bunVM(), arguments.slice());
             defer slice.deinit();
 
             const args = if (comptime Arguments != void)
-                (Arguments.fromJS(globalObject, &slice, &exceptionref) orelse {
-                    // we might've already thrown
-                    if (exceptionref != null)
-                        globalObject.throwValue(JSC.JSValue.c(exceptionref));
-                    return .zero;
-                })
+                (try Arguments.fromJS(globalObject, &slice))
             else
                 Arguments{};
             defer {
                 if (comptime Arguments != void and @hasDecl(Arguments, "deinit")) args.deinit();
             }
 
-            const exception1 = JSC.JSValue.c(exceptionref);
-
-            if (exception1 != .zero) {
-                globalObject.throwValue(exception1);
-                return .zero;
-            } else if (globalObject.hasException()) {
+            if (globalObject.hasException()) {
                 return .zero;
             }
             var result = Function(
@@ -91,30 +79,20 @@ fn call(comptime FunctionEnum: NodeFSFunctionEnum) NodeFSFunction {
     comptime if (function.params.len != 3) @compileError("Expected 3 arguments");
     const Arguments = comptime function.params[1].type.?;
     const NodeBindingClosure = struct {
-        pub fn bind(this: *JSC.Node.NodeJSFS, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn bind(this: *JSC.Node.NodeJSFS, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             var arguments = callframe.arguments(8);
 
             var slice = ArgumentsSlice.init(globalObject.bunVM(), arguments.slice());
             slice.will_be_async = true;
-            var exceptionref: JSC.C.JSValueRef = null;
             const args = if (comptime Arguments != void)
-                (Arguments.fromJS(globalObject, &slice, &exceptionref) orelse {
-                    // we might've already thrown
-                    if (exceptionref != null)
-                        globalObject.throwValue(JSC.JSValue.c(exceptionref));
+                (Arguments.fromJS(globalObject, &slice) catch {
                     slice.deinit();
                     return .zero;
                 })
             else
                 Arguments{};
 
-            const exception1 = JSC.JSValue.c(exceptionref);
-
-            if (exception1 != .zero) {
-                globalObject.throwValue(exception1);
-                slice.deinit();
-                return .zero;
-            } else if (globalObject.hasException()) {
+            if (globalObject.hasException()) {
                 slice.deinit();
                 return .zero;
             }
@@ -142,11 +120,6 @@ pub const NodeJSFS = struct {
     pub usingnamespace JSC.Codegen.JSNodeJSFS;
     pub usingnamespace bun.New(@This());
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*@This() {
-        globalObject.throw("Not a constructor", .{});
-        return null;
-    }
-
     pub fn finalize(this: *JSC.Node.NodeJSFS) void {
         if (this.node_fs.vm) |vm| {
             if (vm.node_fs == &this.node_fs) {
@@ -261,13 +234,12 @@ pub fn createBinding(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
     const module = NodeJSFS.new(.{});
 
     const vm = globalObject.bunVM();
-    if (vm.standalone_module_graph != null)
-        module.node_fs.vm = vm;
+    module.node_fs.vm = vm;
 
     return module.toJS(globalObject);
 }
 
-pub fn createMemfdForTesting(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+pub fn createMemfdForTesting(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callFrame.arguments(1);
 
     if (arguments.len < 1) {
diff --git a/src/bun.js/node/node_fs_stat_watcher.zig b/src/bun.js/node/node_fs_stat_watcher.zig
index 5f197a0c1b0223..b18414b94757a3 100644
--- a/src/bun.js/node/node_fs_stat_watcher.zig
+++ b/src/bun.js/node/node_fs_stat_watcher.zig
@@ -234,22 +234,12 @@ pub const StatWatcher = struct {
 
         global_this: JSC.C.JSContextRef,
 
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Arguments {
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Arguments {
             const vm = ctx.vm();
-            const path = PathLike.fromJSWithAllocator(ctx, arguments, bun.default_allocator, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "filename must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const path = try PathLike.fromJSWithAllocator(ctx, arguments, bun.default_allocator) orelse {
+                return ctx.throwInvalidArguments2("filename must be a string or TypedArray", .{});
             };
 
-            if (exception.* != null) return null;
-
             var listener: JSC.JSValue = .zero;
             var persistent: bool = true;
             var bigint: bool = false;
@@ -259,20 +249,14 @@ pub const StatWatcher = struct {
                 // options
                 if (options_or_callable.isObject()) {
                     // default true
-                    persistent = (options_or_callable.getOptional(ctx, "persistent", bool) catch return null) orelse true;
+                    persistent = (try options_or_callable.getBooleanStrict(ctx, "persistent")) orelse true;
 
                     // default false
-                    bigint = (options_or_callable.getOptional(ctx, "bigint", bool) catch return null) orelse false;
+                    bigint = (try options_or_callable.getBooleanStrict(ctx, "bigint")) orelse false;
 
                     if (options_or_callable.get(ctx, "interval")) |interval_| {
                         if (!interval_.isNumber() and !interval_.isAnyInt()) {
-                            JSC.throwInvalidArguments(
-                                "interval must be a number.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                            return null;
+                            return ctx.throwInvalidArguments2("interval must be a number", .{});
                         }
                         interval = interval_.coerce(i32, ctx);
                     }
@@ -286,8 +270,7 @@ pub const StatWatcher = struct {
             }
 
             if (listener == .zero) {
-                exception.* = JSC.toInvalidArguments("Expected \"listener\" callback", .{}, ctx).asObjectRef();
-                return null;
+                return ctx.throwInvalidArguments2("Expected \"listener\" callback", .{});
             }
 
             return Arguments{
@@ -309,7 +292,7 @@ pub const StatWatcher = struct {
         }
     };
 
-    pub fn doRef(this: *StatWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn doRef(this: *StatWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         if (!this.closed and !this.persistent) {
             this.persistent = true;
             this.poll_ref.ref(this.ctx);
@@ -317,7 +300,7 @@ pub const StatWatcher = struct {
         return .undefined;
     }
 
-    pub fn doUnref(this: *StatWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn doUnref(this: *StatWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         if (this.persistent) {
             this.persistent = false;
             this.poll_ref.unref(this.ctx);
@@ -343,7 +326,7 @@ pub const StatWatcher = struct {
         this.last_jsvalue.clear();
     }
 
-    pub fn doClose(this: *StatWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn doClose(this: *StatWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         this.close();
         return .undefined;
     }
diff --git a/src/bun.js/node/node_fs_watcher.zig b/src/bun.js/node/node_fs_watcher.zig
index 8eeb4acd95737a..d9f294aaf04ad7 100644
--- a/src/bun.js/node/node_fs_watcher.zig
+++ b/src/bun.js/node/node_fs_watcher.zig
@@ -340,23 +340,15 @@ pub const FSWatcher = struct {
         recursive: bool,
         encoding: JSC.Node.Encoding,
         verbose: bool,
-        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Arguments {
+
+        pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!Arguments {
             const vm = ctx.vm();
-            const path = PathLike.fromJS(ctx, arguments, exception) orelse {
-                if (exception.* == null) {
-                    JSC.throwInvalidArguments(
-                        "filename must be a string or TypedArray",
-                        .{},
-                        ctx,
-                        exception,
-                    );
-                }
-                return null;
+            const path = try PathLike.fromJS(ctx, arguments) orelse {
+                return ctx.throwInvalidArguments2("filename must be a string or TypedArray", .{});
             };
             var should_deinit_path = true;
             defer if (should_deinit_path) path.deinit();
 
-            if (exception.* != null) return null;
             var listener: JSC.JSValue = .zero;
             var signal: ?*JSC.AbortSignal = null;
             var persistent: bool = true;
@@ -367,86 +359,58 @@ pub const FSWatcher = struct {
 
                 // options
                 if (options_or_callable.isObject()) {
-                    if (options_or_callable.getTruthy(ctx, "persistent")) |persistent_| {
+                    if (try options_or_callable.getTruthy(ctx, "persistent")) |persistent_| {
                         if (!persistent_.isBoolean()) {
-                            JSC.throwInvalidArguments(
-                                "persistent must be a boolean.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                            return null;
+                            return ctx.throwInvalidArguments2("persistent must be a boolean", .{});
                         }
                         persistent = persistent_.toBoolean();
                     }
 
-                    if (options_or_callable.getTruthy(ctx, "verbose")) |verbose_| {
+                    if (try options_or_callable.getTruthy(ctx, "verbose")) |verbose_| {
                         if (!verbose_.isBoolean()) {
-                            JSC.throwInvalidArguments(
-                                "verbose must be a boolean.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                            return null;
+                            return ctx.throwInvalidArguments2("verbose must be a boolean", .{});
                         }
                         verbose = verbose_.toBoolean();
                     }
 
                     if (options_or_callable.fastGet(ctx, .encoding)) |encoding_| {
-                        encoding = JSC.Node.Encoding.assert(encoding_, ctx, encoding) catch return null;
+                        encoding = try JSC.Node.Encoding.assert(encoding_, ctx, encoding);
                     }
 
-                    if (options_or_callable.getTruthy(ctx, "recursive")) |recursive_| {
+                    if (try options_or_callable.getTruthy(ctx, "recursive")) |recursive_| {
                         if (!recursive_.isBoolean()) {
-                            JSC.throwInvalidArguments(
-                                "recursive must be a boolean.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-                            return null;
+                            return ctx.throwInvalidArguments2("recursive must be a boolean", .{});
                         }
                         recursive = recursive_.toBoolean();
                     }
 
                     // abort signal
-                    if (options_or_callable.getTruthy(ctx, "signal")) |signal_| {
+                    if (try options_or_callable.getTruthy(ctx, "signal")) |signal_| {
                         if (JSC.AbortSignal.fromJS(signal_)) |signal_obj| {
                             //Keep it alive
                             signal_.ensureStillAlive();
                             signal = signal_obj;
                         } else {
-                            JSC.throwInvalidArguments(
-                                "signal is not of type AbortSignal.",
-                                .{},
-                                ctx,
-                                exception,
-                            );
-
-                            return null;
+                            return ctx.throwInvalidArguments2("signal is not of type AbortSignal", .{});
                         }
                     }
 
                     // listener
                     if (arguments.nextEat()) |callable| {
                         if (!callable.isCell() or !callable.isCallable(vm)) {
-                            exception.* = JSC.toInvalidArguments("Expected \"listener\" callback to be a function", .{}, ctx).asObjectRef();
-                            return null;
+                            return ctx.throwInvalidArguments2("Expected \"listener\" callback to be a function", .{});
                         }
                         listener = callable;
                     }
                 } else {
                     if (!options_or_callable.isCell() or !options_or_callable.isCallable(vm)) {
-                        exception.* = JSC.toInvalidArguments("Expected \"listener\" callback to be a function", .{}, ctx).asObjectRef();
-                        return null;
+                        return ctx.throwInvalidArguments2("Expected \"listener\" callback to be a function", .{});
                     }
                     listener = options_or_callable;
                 }
             }
             if (listener == .zero) {
-                exception.* = JSC.toInvalidArguments("Expected \"listener\" callback", .{}, ctx).asObjectRef();
-                return null;
+                return ctx.throwInvalidArguments2("Expected \"listener\" callback", .{});
             }
 
             should_deinit_path = false;
@@ -591,7 +555,7 @@ pub const FSWatcher = struct {
         ) catch |err| globalObject.reportActiveExceptionAsUnhandled(err);
     }
 
-    pub fn doRef(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn doRef(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         if (!this.closed and !this.persistent) {
             this.persistent = true;
             this.poll_ref.ref(this.ctx);
@@ -599,7 +563,7 @@ pub const FSWatcher = struct {
         return .undefined;
     }
 
-    pub fn doUnref(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn doUnref(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         if (this.persistent) {
             this.persistent = false;
             this.poll_ref.unref(this.ctx);
@@ -607,7 +571,7 @@ pub const FSWatcher = struct {
         return .undefined;
     }
 
-    pub fn hasRef(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn hasRef(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.persistent);
     }
 
@@ -677,7 +641,7 @@ pub const FSWatcher = struct {
         this.js_this = .zero;
     }
 
-    pub fn doClose(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn doClose(this: *FSWatcher, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         this.close();
         return .undefined;
     }
diff --git a/src/bun.js/node/node_http_binding.zig b/src/bun.js/node/node_http_binding.zig
index a393736cd2c05b..6a4407ba0a5b56 100644
--- a/src/bun.js/node/node_http_binding.zig
+++ b/src/bun.js/node/node_http_binding.zig
@@ -7,11 +7,10 @@ const Output = bun.Output;
 const ZigString = JSC.ZigString;
 const uv = bun.windows.libuv;
 
-pub fn getBunServerAllClosedPromise(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn getBunServerAllClosedPromise(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1).slice();
     if (arguments.len < 1) {
-        globalThis.throwNotEnoughArguments("getBunServerAllClosePromise", 1, arguments.len);
-        return .zero;
+        return globalThis.throwNotEnoughArguments("getBunServerAllClosePromise", 1, arguments.len);
     }
 
     const value = arguments[0];
@@ -30,17 +29,16 @@ pub fn getBunServerAllClosedPromise(globalThis: *JSC.JSGlobalObject, callframe:
     return globalThis.throwInvalidArgumentTypeValue("server", "bun.Server", value);
 }
 
-pub fn getMaxHTTPHeaderSize(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn getMaxHTTPHeaderSize(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     _ = globalThis; // autofix
     _ = callframe; // autofix
     return JSC.JSValue.jsNumber(bun.http.max_http_header_size);
 }
 
-pub fn setMaxHTTPHeaderSize(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn setMaxHTTPHeaderSize(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1).slice();
     if (arguments.len < 1) {
-        globalThis.throwNotEnoughArguments("setMaxHTTPHeaderSize", 1, arguments.len);
-        return .zero;
+        return globalThis.throwNotEnoughArguments("setMaxHTTPHeaderSize", 1, arguments.len);
     }
     const value = arguments[0];
     const num = value.coerceToInt64(globalThis);
diff --git a/src/bun.js/node/node_net_binding.zig b/src/bun.js/node/node_net_binding.zig
index 8a4854261fa7f5..c7819c4314db82 100644
--- a/src/bun.js/node/node_net_binding.zig
+++ b/src/bun.js/node/node_net_binding.zig
@@ -13,7 +13,7 @@ pub var autoSelectFamilyDefault: bool = true;
 
 pub fn getDefaultAutoSelectFamily(global: *JSC.JSGlobalObject) JSC.JSValue {
     return JSC.JSFunction.create(global, "getDefaultAutoSelectFamily", (struct {
-        fn getter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+        fn getter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             _ = globalThis;
             _ = callframe;
             return JSC.jsBoolean(autoSelectFamilyDefault);
@@ -23,7 +23,7 @@ pub fn getDefaultAutoSelectFamily(global: *JSC.JSGlobalObject) JSC.JSValue {
 
 pub fn setDefaultAutoSelectFamily(global: *JSC.JSGlobalObject) JSC.JSValue {
     return JSC.JSFunction.create(global, "setDefaultAutoSelectFamily", (struct {
-        fn setter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+        fn setter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(1);
             if (arguments.len < 1) {
                 globalThis.throw("missing argument", .{});
@@ -48,7 +48,7 @@ pub var autoSelectFamilyAttemptTimeoutDefault: u32 = 250;
 
 pub fn getDefaultAutoSelectFamilyAttemptTimeout(global: *JSC.JSGlobalObject) JSC.JSValue {
     return JSC.JSFunction.create(global, "getDefaultAutoSelectFamilyAttemptTimeout", (struct {
-        fn getter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+        fn getter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             _ = globalThis;
             _ = callframe;
             return JSC.jsNumber(autoSelectFamilyAttemptTimeoutDefault);
@@ -58,7 +58,7 @@ pub fn getDefaultAutoSelectFamilyAttemptTimeout(global: *JSC.JSGlobalObject) JSC
 
 pub fn setDefaultAutoSelectFamilyAttemptTimeout(global: *JSC.JSGlobalObject) JSC.JSValue {
     return JSC.JSFunction.create(global, "setDefaultAutoSelectFamilyAttemptTimeout", (struct {
-        fn setter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+        fn setter(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(1);
             if (arguments.len < 1) {
                 globalThis.throw("missing argument", .{});
diff --git a/src/bun.js/node/node_os.zig b/src/bun.js/node/node_os.zig
index c18a7b5860eb53..ee0f8af2a6909c 100644
--- a/src/bun.js/node/node_os.zig
+++ b/src/bun.js/node/node_os.zig
@@ -51,7 +51,7 @@ pub const OS = struct {
         }
     };
 
-    pub fn cpus(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn cpus(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         return switch (Environment.os) {
@@ -294,19 +294,19 @@ pub const OS = struct {
         return values;
     }
 
-    pub fn endianness(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn endianness(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         return JSC.ZigString.init("LE").withEncoding().toJS(globalThis);
     }
 
-    pub fn freemem(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn freemem(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         return JSC.JSValue.jsNumberFromUint64(C.getFreeMemory());
     }
 
-    pub fn getPriority(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn getPriority(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         var args_ = callframe.arguments(1);
@@ -345,7 +345,7 @@ pub const OS = struct {
         return JSC.JSValue.jsNumberFromInt32(priority);
     }
 
-    pub fn homedir(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn homedir(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         const dir: []const u8 = brk: {
@@ -363,7 +363,7 @@ pub const OS = struct {
         return JSC.ZigString.init(dir).withEncoding().toJS(globalThis);
     }
 
-    pub fn hostname(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn hostname(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         if (comptime Environment.isWindows) {
@@ -391,7 +391,7 @@ pub const OS = struct {
         return JSC.ZigString.init(std.posix.gethostname(&name_buffer) catch "unknown").withEncoding().toJS(globalThis);
     }
 
-    pub fn loadavg(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn loadavg(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         const result = C.getSystemLoadavg();
@@ -402,7 +402,7 @@ pub const OS = struct {
         });
     }
 
-    pub fn networkInterfaces(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn networkInterfaces(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         return switch (Environment.os) {
             .windows => networkInterfacesWindows(globalThis),
             else => networkInterfacesPosix(globalThis),
@@ -707,19 +707,19 @@ pub const OS = struct {
         return ret;
     }
 
-    pub fn platform(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn platform(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         return JSC.ZigString.init(Global.os_name).withEncoding().toJS(globalThis);
     }
 
-    pub fn release(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn release(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         var name_buffer: [bun.HOST_NAME_MAX]u8 = undefined;
         return JSC.ZigString.init(C.getRelease(&name_buffer)).withEncoding().toJS(globalThis);
     }
 
-    pub fn setPriority(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setPriority(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         var args_ = callframe.arguments(2);
@@ -782,13 +782,13 @@ pub const OS = struct {
         return .undefined;
     }
 
-    pub fn totalmem(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn totalmem(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         return JSC.JSValue.jsNumberFromUint64(C.getTotalMemory());
     }
 
-    pub fn @"type"(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn @"type"(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         if (comptime Environment.isWindows)
@@ -801,7 +801,7 @@ pub const OS = struct {
         return JSC.ZigString.init(Global.os_name).withEncoding().toJS(globalThis);
     }
 
-    pub fn uptime(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn uptime(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         if (Environment.isWindows) {
             var uptime_value: f64 = undefined;
             const err = libuv.uv_uptime(&uptime_value);
@@ -821,10 +821,10 @@ pub const OS = struct {
         return JSC.JSValue.jsNumberFromUint64(C.getSystemUptime());
     }
 
-    pub fn userInfo(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn userInfo(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const result = JSC.JSValue.createEmptyObject(globalThis, 5);
 
-        result.put(globalThis, JSC.ZigString.static("homedir"), homedir(globalThis, callframe));
+        result.put(globalThis, JSC.ZigString.static("homedir"), try homedir(globalThis, callframe));
 
         if (comptime Environment.isWindows) {
             result.put(globalThis, JSC.ZigString.static("username"), JSC.ZigString.init(bun.getenvZ("USERNAME") orelse "unknown").withEncoding().toJS(globalThis));
@@ -844,7 +844,7 @@ pub const OS = struct {
         return result;
     }
 
-    pub fn version(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn version(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         var name_buffer: [bun.HOST_NAME_MAX]u8 = undefined;
         return JSC.ZigString.init(C.getVersion(&name_buffer)).withEncoding().toJS(globalThis);
@@ -865,7 +865,7 @@ pub const OS = struct {
         };
     }
 
-    pub fn machine(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn machine(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
         return JSC.ZigString.static(comptime getMachineName()).toJS(globalThis);
     }
diff --git a/src/bun.js/node/node_util_binding.zig b/src/bun.js/node/node_util_binding.zig
index dfbbcca6539d7c..9db9a3ddfce560 100644
--- a/src/bun.js/node/node_util_binding.zig
+++ b/src/bun.js/node/node_util_binding.zig
@@ -7,11 +7,10 @@ const Output = bun.Output;
 const ZigString = JSC.ZigString;
 const uv = bun.windows.libuv;
 
-pub fn internalErrorName(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+pub fn internalErrorName(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1).slice();
     if (arguments.len < 1) {
-        globalThis.throwNotEnoughArguments("internalErrorName", 1, arguments.len);
-        return .zero;
+        return globalThis.throwNotEnoughArguments("internalErrorName", 1, arguments.len);
     }
 
     const err_value = arguments[0];
diff --git a/src/bun.js/node/node_zlib_binding.zig b/src/bun.js/node/node_zlib_binding.zig
index 02aca9890f107c..40a0dea83c13e1 100644
--- a/src/bun.js/node/node_zlib_binding.zig
+++ b/src/bun.js/node/node_zlib_binding.zig
@@ -7,12 +7,11 @@ const Output = bun.Output;
 const ZigString = JSC.ZigString;
 const validators = @import("./util/validators.zig");
 
-pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSC.JSValue {
+pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(2).ptr;
 
     const data: ZigString.Slice = blk: {
         const data: JSC.JSValue = arguments[0];
-        var exceptionref: JSC.C.JSValueRef = null;
 
         if (data == .zero) {
             return globalThis.throwInvalidArgumentTypeValue("data", "string or an instance of Buffer, TypedArray, or DataView", .undefined);
@@ -20,16 +19,12 @@ pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callcon
         if (data.isString()) {
             break :blk data.asString().toSlice(globalThis, bun.default_allocator);
         }
-        const buffer: JSC.Buffer = JSC.Buffer.fromJS(globalThis, data, &exceptionref) orelse {
+        const buffer: JSC.Buffer = JSC.Buffer.fromJS(globalThis, data) orelse {
             const ty_str = data.jsTypeString(globalThis).toSlice(globalThis, bun.default_allocator);
             defer ty_str.deinit();
             globalThis.ERR_INVALID_ARG_TYPE("The \"data\" property must be an instance of Buffer, TypedArray, DataView, or ArrayBuffer. Received {s}", .{ty_str.slice()}).throw();
             return .zero;
         };
-        if (exceptionref) |ptr| {
-            globalThis.throwValue(JSC.JSValue.c(ptr));
-            return .zero;
-        }
         break :blk ZigString.Slice.fromUTF8NeverFree(buffer.slice());
     };
     defer data.deinit();
@@ -64,7 +59,7 @@ pub fn crc32(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callcon
 
 pub fn CompressionStream(comptime T: type) type {
     return struct {
-        pub fn write(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn write(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.argumentsUndef(7).slice();
 
             if (arguments.len != 7) {
@@ -156,7 +151,7 @@ pub fn CompressionStream(comptime T: type) type {
             if (this.pending_close) _ = this._close();
         }
 
-        pub fn writeSync(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn writeSync(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.argumentsUndef(7).slice();
 
             if (arguments.len != 7) {
@@ -206,7 +201,7 @@ pub fn CompressionStream(comptime T: type) type {
             //
 
             this.stream.doWork();
-            if (this.checkError(globalThis) catch return .zero) {
+            if (try this.checkError(globalThis)) {
                 this.stream.updateWriteResult(&this.write_result.?[1], &this.write_result.?[0]);
                 this.write_in_progress = false;
             }
@@ -215,17 +210,17 @@ pub fn CompressionStream(comptime T: type) type {
             return .undefined;
         }
 
-        pub fn reset(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn reset(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             _ = callframe;
 
             const err = this.stream.reset();
             if (err.isError()) {
-                this.emitError(globalThis, err) catch return .zero;
+                try this.emitError(globalThis, err);
             }
             return .undefined;
         }
 
-        pub fn close(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn close(this: *T, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             _ = globalThis;
             _ = callframe;
             this._close();
@@ -326,23 +321,23 @@ pub const SNativeZlib = struct {
     closed: bool = false,
     task: JSC.WorkPoolTask = .{ .callback = undefined },
 
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*@This() {
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*@This() {
         const arguments = callframe.argumentsUndef(4).ptr;
 
         var mode = arguments[0];
         if (!mode.isNumber()) {
             _ = globalThis.throwInvalidArgumentTypeValue("mode", "number", mode);
-            return null;
+            return error.JSError;
         }
         const mode_double = mode.asNumber();
         if (@mod(mode_double, 1.0) != 0.0) {
             _ = globalThis.throwInvalidArgumentTypeValue("mode", "integer", mode);
-            return null;
+            return error.JSError;
         }
         const mode_int: i64 = @intFromFloat(mode_double);
         if (mode_int < 1 or mode_int > 7) {
             _ = globalThis.throwRangeError(mode_int, .{ .field_name = "mode", .min = 1, .max = 7 });
-            return null;
+            return error.JSError;
         }
 
         const ptr = SNativeZlib.new(.{
@@ -360,7 +355,7 @@ pub const SNativeZlib = struct {
     //     return @sizeOf(SNativeZlib) + internal_state_size;
     // }
 
-    pub fn init(this: *SNativeZlib, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn init(this: *SNativeZlib, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.argumentsUndef(7).slice();
 
         if (arguments.len != 7) {
@@ -368,13 +363,13 @@ pub const SNativeZlib = struct {
             return .zero;
         }
 
-        const windowBits = validators.validateInt32(globalThis, arguments[0], "windowBits", .{}, null, null) catch return .zero;
-        const level = validators.validateInt32(globalThis, arguments[1], "level", .{}, null, null) catch return .zero;
-        const memLevel = validators.validateInt32(globalThis, arguments[2], "memLevel", .{}, null, null) catch return .zero;
-        const strategy = validators.validateInt32(globalThis, arguments[3], "strategy", .{}, null, null) catch return .zero;
+        const windowBits = try validators.validateInt32(globalThis, arguments[0], "windowBits", .{}, null, null);
+        const level = try validators.validateInt32(globalThis, arguments[1], "level", .{}, null, null);
+        const memLevel = try validators.validateInt32(globalThis, arguments[2], "memLevel", .{}, null, null);
+        const strategy = try validators.validateInt32(globalThis, arguments[3], "strategy", .{}, null, null);
         // this does not get gc'd because it is stored in the JS object's `this._writeState`. and the JS object is tied to the native handle as `_handle[owner_symbol]`.
         const writeResult = arguments[4].asArrayBuffer(globalThis).?.asU32().ptr;
-        const writeCallback = validators.validateFunction(globalThis, arguments[5], "writeCallback", .{}) catch return .zero;
+        const writeCallback = try validators.validateFunction(globalThis, arguments[5], "writeCallback", .{});
         const dictionary = if (arguments[6].isUndefined()) null else arguments[6].asArrayBuffer(globalThis).?.byteSlice();
 
         this.write_result = writeResult;
@@ -385,7 +380,7 @@ pub const SNativeZlib = struct {
         return .undefined;
     }
 
-    pub fn params(this: *SNativeZlib, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn params(this: *SNativeZlib, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.argumentsUndef(2).slice();
 
         if (arguments.len != 2) {
@@ -393,12 +388,12 @@ pub const SNativeZlib = struct {
             return .zero;
         }
 
-        const level = validators.validateInt32(globalThis, arguments[0], "level", .{}, null, null) catch return .zero;
-        const strategy = validators.validateInt32(globalThis, arguments[1], "strategy", .{}, null, null) catch return .zero;
+        const level = try validators.validateInt32(globalThis, arguments[0], "level", .{}, null, null);
+        const strategy = try validators.validateInt32(globalThis, arguments[1], "strategy", .{}, null, null);
 
         const err = this.stream.setParams(level, strategy);
         if (err.isError()) {
-            this.emitError(globalThis, err) catch return .zero;
+            try this.emitError(globalThis, err);
         }
         return .undefined;
     }
@@ -686,23 +681,23 @@ pub const SNativeBrotli = struct {
         .callback = undefined,
     },
 
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*@This() {
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*@This() {
         const arguments = callframe.argumentsUndef(1).ptr;
 
         var mode = arguments[0];
         if (!mode.isNumber()) {
             _ = globalThis.throwInvalidArgumentTypeValue("mode", "number", mode);
-            return null;
+            return error.JSError;
         }
         const mode_double = mode.asNumber();
         if (@mod(mode_double, 1.0) != 0.0) {
             _ = globalThis.throwInvalidArgumentTypeValue("mode", "integer", mode);
-            return null;
+            return error.JSError;
         }
         const mode_int: i64 = @intFromFloat(mode_double);
         if (mode_int < 8 or mode_int > 9) {
             _ = globalThis.throwRangeError(mode_int, .{ .field_name = "mode", .min = 8, .max = 9 });
-            return null;
+            return error.JSError;
         }
 
         const ptr = @This().new(.{
@@ -724,7 +719,7 @@ pub const SNativeBrotli = struct {
         };
     }
 
-    pub fn init(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn init(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.argumentsUndef(3).slice();
         if (arguments.len != 3) {
             globalThis.ERR_MISSING_ARGS("init(params, writeResult, writeCallback)", .{}).throw();
@@ -733,13 +728,13 @@ pub const SNativeBrotli = struct {
 
         // this does not get gc'd because it is stored in the JS object's `this._writeState`. and the JS object is tied to the native handle as `_handle[owner_symbol]`.
         const writeResult = arguments[1].asArrayBuffer(globalThis).?.asU32().ptr;
-        const writeCallback = validators.validateFunction(globalThis, arguments[2], "writeCallback", .{}) catch return .zero;
+        const writeCallback = try validators.validateFunction(globalThis, arguments[2], "writeCallback", .{});
         this.write_result = writeResult;
         this.write_callback.set(globalThis, writeCallback);
 
         var err = this.stream.init();
         if (err.isError()) {
-            this.emitError(globalThis, err) catch return .zero;
+            try this.emitError(globalThis, err);
             return JSC.jsBoolean(false);
         }
 
@@ -752,14 +747,14 @@ pub const SNativeBrotli = struct {
             }
             err = this.stream.setParams(@intCast(i), d);
             if (err.isError()) {
-                // this.emitError(globalThis, err) catch return .zero; //XXX: onerror isn't set yet
+                // try this.emitError(globalThis, err); //XXX: onerror isn't set yet
                 return JSC.jsBoolean(false);
             }
         }
         return JSC.jsBoolean(true);
     }
 
-    pub fn params(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn params(this: *@This(), globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         _ = this;
         _ = globalThis;
         _ = callframe;
diff --git a/src/bun.js/node/path.zig b/src/bun.js/node/path.zig
index d271f495c49ec6..6e73e687cae36a 100644
--- a/src/bun.js/node/path.zig
+++ b/src/bun.js/node/path.zig
@@ -958,7 +958,7 @@ pub fn formatJS_T(comptime T: type, globalObject: *JSC.JSGlobalObject, allocator
     return if (isWindows) formatWindowsJS_T(T, globalObject, pathObject, buf) else formatPosixJS_T(T, globalObject, pathObject, buf);
 }
 
-pub fn format(globalObject: *JSC.JSGlobalObject, isWindows: bool, args_ptr: [*]JSC.JSValue, args_len: u16) callconv(JSC.conv) JSC.JSValue {
+pub fn format(globalObject: *JSC.JSGlobalObject, isWindows: bool, args_ptr: [*]JSC.JSValue, args_len: u16) bun.JSError!JSC.JSValue {
     const pathObject_ptr = if (args_len > 0) args_ptr[0] else .undefined;
     // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validateObject(globalObject, pathObject_ptr, "pathObject", .{}, .{}) catch {
@@ -970,24 +970,24 @@ pub fn format(globalObject: *JSC.JSGlobalObject, isWindows: bool, args_ptr: [*]J
     const allocator = stack_fallback.get();
 
     var root: []const u8 = "";
-    if (pathObject_ptr.getTruthy(globalObject, "root")) |jsValue| {
+    if (try pathObject_ptr.getTruthy(globalObject, "root")) |jsValue| {
         root = jsValue.toSlice(globalObject, allocator).slice();
     }
     var dir: []const u8 = "";
-    if (pathObject_ptr.getTruthy(globalObject, "dir")) |jsValue| {
+    if (try pathObject_ptr.getTruthy(globalObject, "dir")) |jsValue| {
         dir = jsValue.toSlice(globalObject, allocator).slice();
     }
     var base: []const u8 = "";
-    if (pathObject_ptr.getTruthy(globalObject, "base")) |jsValue| {
+    if (try pathObject_ptr.getTruthy(globalObject, "base")) |jsValue| {
         base = jsValue.toSlice(globalObject, allocator).slice();
     }
     // Prefix with _ to avoid shadowing the identifier in the outer scope.
     var _name: []const u8 = "";
-    if (pathObject_ptr.getTruthy(globalObject, "name")) |jsValue| {
+    if (try pathObject_ptr.getTruthy(globalObject, "name")) |jsValue| {
         _name = jsValue.toSlice(globalObject, allocator).slice();
     }
     var ext: []const u8 = "";
-    if (pathObject_ptr.getTruthy(globalObject, "ext")) |jsValue| {
+    if (try pathObject_ptr.getTruthy(globalObject, "ext")) |jsValue| {
         ext = jsValue.toSlice(globalObject, allocator).slice();
     }
     return formatJS_T(u8, globalObject, allocator, isWindows, .{ .root = root, .dir = dir, .base = base, .ext = ext, .name = _name });
@@ -2953,7 +2953,7 @@ comptime {
     @export(Path.basename, .{ .name = shim.symbolName("basename") });
     @export(Path.dirname, .{ .name = shim.symbolName("dirname") });
     @export(Path.extname, .{ .name = shim.symbolName("extname") });
-    @export(Path.format, .{ .name = shim.symbolName("format") });
+    @export(path_format, .{ .name = shim.symbolName("format") });
     @export(Path.isAbsolute, .{ .name = shim.symbolName("isAbsolute") });
     @export(Path.join, .{ .name = shim.symbolName("join") });
     @export(Path.normalize, .{ .name = shim.symbolName("normalize") });
@@ -2962,3 +2962,10 @@ comptime {
     @export(Path.resolve, .{ .name = shim.symbolName("resolve") });
     @export(Path.toNamespacedPath, .{ .name = shim.symbolName("toNamespacedPath") });
 }
+
+fn path_format(globalObject: *JSC.JSGlobalObject, isWindows: bool, args_ptr: [*]JSC.JSValue, args_len: u16) callconv(JSC.conv) JSC.JSValue {
+    return Path.format(globalObject, isWindows, args_ptr, args_len) catch |err| switch (err) {
+        error.JSError => .zero,
+        error.OutOfMemory => globalObject.throwOutOfMemoryValue(),
+    };
+}
diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig
index 4f9af557d77e08..08d38ca328496d 100644
--- a/src/bun.js/node/types.zig
+++ b/src/bun.js/node/types.zig
@@ -23,7 +23,7 @@ const Shimmer = @import("../bindings/shimmer.zig").Shimmer;
 const Syscall = bun.sys;
 const URL = @import("../../url.zig").URL;
 const Value = std.json.Value;
-const validators = @import("./util/validators.zig");
+pub const validators = @import("./util/validators.zig");
 
 pub const Path = @import("./path.zig");
 
@@ -370,15 +370,15 @@ pub const BlobOrStringOrBuffer = union(enum) {
         return .{ .string_or_buffer = StringOrBuffer.fromJS(global, allocator, value) orelse return null };
     }
 
-    pub fn fromJSWithEncodingValue(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue) ?BlobOrStringOrBuffer {
+    pub fn fromJSWithEncodingValue(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue) bun.JSError!?BlobOrStringOrBuffer {
         return fromJSWithEncodingValueMaybeAsync(global, allocator, value, encoding_value, false);
     }
 
-    pub fn fromJSWithEncodingValueMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue, is_async: bool) ?BlobOrStringOrBuffer {
+    pub fn fromJSWithEncodingValueMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue, is_async: bool) bun.JSError!?BlobOrStringOrBuffer {
         return fromJSWithEncodingValueMaybeAsyncAllowRequestResponse(global, allocator, value, encoding_value, is_async, false);
     }
 
-    pub fn fromJSWithEncodingValueMaybeAsyncAllowRequestResponse(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue, is_async: bool, allow_request_response: bool) ?BlobOrStringOrBuffer {
+    pub fn fromJSWithEncodingValueMaybeAsyncAllowRequestResponse(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue, is_async: bool, allow_request_response: bool) bun.JSError!?BlobOrStringOrBuffer {
         switch (value.jsType()) {
             .DOMWrapper => {
                 if (value.as(JSC.WebCore.Blob)) |blob| {
@@ -397,8 +397,7 @@ pub const BlobOrStringOrBuffer = union(enum) {
                             return .{ .blob = any_blob.toBlob(global) };
                         }
 
-                        global.throwInvalidArguments("Only buffered Request/Response bodies are supported for now.", .{});
-                        return null;
+                        return global.throwInvalidArguments2("Only buffered Request/Response bodies are supported for now.", .{});
                     }
 
                     if (value.as(JSC.WebCore.Response)) |response| {
@@ -410,15 +409,14 @@ pub const BlobOrStringOrBuffer = union(enum) {
                             return .{ .blob = any_blob.toBlob(global) };
                         }
 
-                        global.throwInvalidArguments("Only buffered Request/Response bodies are supported for now.", .{});
-                        return null;
+                        return global.throwInvalidArguments2("Only buffered Request/Response bodies are supported for now.", .{});
                     }
                 }
             },
             else => {},
         }
 
-        return .{ .string_or_buffer = StringOrBuffer.fromJSWithEncodingValueMaybeAsync(global, allocator, value, encoding_value, is_async) orelse return null };
+        return .{ .string_or_buffer = try StringOrBuffer.fromJSWithEncodingValueMaybeAsync(global, allocator, value, encoding_value, is_async) orelse return null };
     }
 };
 
@@ -453,14 +451,14 @@ pub const StringOrBuffer = union(enum) {
         }
     }
 
-    pub fn fromJSToOwnedSlice(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue, allocator: std.mem.Allocator) ![]u8 {
+    pub fn fromJSToOwnedSlice(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue, allocator: std.mem.Allocator) bun.JSError![]u8 {
         if (value.asArrayBuffer(globalObject)) |array_buffer| {
             defer globalObject.vm().reportExtraMemory(array_buffer.len);
 
             return try allocator.dupe(u8, array_buffer.byteSlice());
         }
 
-        const str = bun.String.tryFromJS(value, globalObject) orelse return error.JSError;
+        const str = try bun.String.fromJS2(value, globalObject);
         defer str.deref();
 
         const result = try str.toOwnedSlice(allocator);
@@ -532,8 +530,11 @@ pub const StringOrBuffer = union(enum) {
 
     pub fn fromJSMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, is_async: bool) ?StringOrBuffer {
         return switch (value.jsType()) {
-            JSC.JSValue.JSType.String, JSC.JSValue.JSType.StringObject, JSC.JSValue.JSType.DerivedStringObject, JSC.JSValue.JSType.Object => {
-                const str = bun.String.tryFromJS(value, global) orelse return null;
+            .String,
+            .StringObject,
+            .DerivedStringObject,
+            => {
+                const str = bun.String.fromJS(value, global);
 
                 if (is_async) {
                     defer str.deref();
@@ -576,11 +577,11 @@ pub const StringOrBuffer = union(enum) {
         return fromJSMaybeAsync(global, allocator, value, false);
     }
 
-    pub fn fromJSWithEncoding(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding: Encoding) ?StringOrBuffer {
+    pub fn fromJSWithEncoding(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding: Encoding) bun.JSError!?StringOrBuffer {
         return fromJSWithEncodingMaybeAsync(global, allocator, value, encoding, false);
     }
 
-    pub fn fromJSWithEncodingMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding: Encoding, is_async: bool) ?StringOrBuffer {
+    pub fn fromJSWithEncodingMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding: Encoding, is_async: bool) bun.JSError!?StringOrBuffer {
         if (value.isCell() and value.jsType().isTypedArray()) {
             return StringOrBuffer{
                 .buffer = Buffer.fromTypedArray(global, value),
@@ -591,7 +592,7 @@ pub const StringOrBuffer = union(enum) {
             return fromJSMaybeAsync(global, allocator, value, is_async);
         }
 
-        var str = bun.String.tryFromJS(value, global) orelse return null;
+        var str = try bun.String.fromJS2(value, global);
         defer str.deref();
         if (str.isEmpty()) {
             return fromJSMaybeAsync(global, allocator, value, is_async);
@@ -605,7 +606,7 @@ pub const StringOrBuffer = union(enum) {
         };
     }
 
-    pub fn fromJSWithEncodingValue(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue) ?StringOrBuffer {
+    pub fn fromJSWithEncodingValue(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue) bun.JSError!?StringOrBuffer {
         const encoding: Encoding = brk: {
             if (!encoding_value.isCell())
                 break :brk .utf8;
@@ -615,7 +616,7 @@ pub const StringOrBuffer = union(enum) {
         return fromJSWithEncoding(global, allocator, value, encoding);
     }
 
-    pub fn fromJSWithEncodingValueMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue, maybe_async: bool) ?StringOrBuffer {
+    pub fn fromJSWithEncodingValueMaybeAsync(global: *JSC.JSGlobalObject, allocator: std.mem.Allocator, value: JSC.JSValue, encoding_value: JSC.JSValue, maybe_async: bool) bun.JSError!?StringOrBuffer {
         const encoding: Encoding = brk: {
             if (!encoding_value.isCell())
                 break :brk .utf8;
@@ -676,24 +677,20 @@ pub const Encoding = enum(u8) {
         return strings.inMapCaseInsensitive(slice, map);
     }
 
-    pub fn assert(value: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) !Encoding {
+    pub fn assert(value: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) bun.JSError!Encoding {
         if (value.isFalsey()) {
             return default;
         }
 
         if (!value.isString()) {
-            throwEncodingError(globalObject, value);
-            return error.JSError;
+            return throwEncodingError(globalObject, value);
         }
 
-        return fromJSWithDefaultOnEmpty(value, globalObject, default) orelse {
-            throwEncodingError(globalObject, value);
-            return error.JSError;
-        };
+        return try fromJSWithDefaultOnEmpty(value, globalObject, default) orelse throwEncodingError(globalObject, value);
     }
 
-    pub fn fromJSWithDefaultOnEmpty(value: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) ?Encoding {
-        const str = bun.String.tryFromJS(value, globalObject) orelse return null;
+    pub fn fromJSWithDefaultOnEmpty(value: JSC.JSValue, globalObject: *JSC.JSGlobalObject, default: Encoding) bun.JSError!?Encoding {
+        const str = try bun.String.fromJS2(value, globalObject);
         defer str.deref();
         if (str.isEmpty()) {
             return default;
@@ -701,13 +698,14 @@ pub const Encoding = enum(u8) {
         return str.inMapCaseInsensitive(Encoding.map);
     }
 
-    pub fn throwEncodingError(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+    pub fn throwEncodingError(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) bun.JSError {
         globalObject.ERR_INVALID_ARG_VALUE(
             "encoding '{}' is an invalid encoding",
             .{
                 value.fmtString(globalObject),
             },
         ).throw();
+        return error.JSError;
     }
 
     pub fn encodeWithSize(encoding: Encoding, globalObject: *JSC.JSGlobalObject, comptime size: usize, input: *const [size]u8) JSC.JSValue {
@@ -926,18 +924,18 @@ pub const PathLike = union(enum) {
         };
     }
 
-    pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?PathLike {
-        return fromJSWithAllocator(ctx, arguments, bun.default_allocator, exception);
+    pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice) bun.JSError!?PathLike {
+        return fromJSWithAllocator(ctx, arguments, bun.default_allocator);
     }
-    pub fn fromJSWithAllocator(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, allocator: std.mem.Allocator, exception: JSC.C.ExceptionRef) ?PathLike {
+
+    pub fn fromJSWithAllocator(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, allocator: std.mem.Allocator) bun.JSError!?PathLike {
         const arg = arguments.next() orelse return null;
         switch (arg.jsType()) {
             JSC.JSValue.JSType.Uint8Array,
             JSC.JSValue.JSType.DataView,
             => {
                 const buffer = Buffer.fromTypedArray(ctx, arg);
-                if (exception.* != null) return null;
-                if (!Valid.pathBuffer(buffer, ctx, exception)) return null;
+                try Valid.pathBuffer(buffer, ctx);
 
                 arguments.protectEat();
                 return PathLike{ .buffer = buffer };
@@ -945,8 +943,7 @@ pub const PathLike = union(enum) {
 
             JSC.JSValue.JSType.ArrayBuffer => {
                 const buffer = Buffer.fromArrayBuffer(ctx, arg);
-                if (exception.* != null) return null;
-                if (!Valid.pathBuffer(buffer, ctx, exception)) return null;
+                try Valid.pathBuffer(buffer, ctx);
 
                 arguments.protectEat();
 
@@ -962,9 +959,7 @@ pub const PathLike = union(enum) {
 
                 arguments.eat();
 
-                if (!Valid.pathStringLength(str.length(), ctx, exception)) {
-                    return null;
-                }
+                try Valid.pathStringLength(str.length(), ctx);
 
                 if (arguments.will_be_async) {
                     var sliced = str.toThreadSafeSlice(allocator);
@@ -995,14 +990,12 @@ pub const PathLike = union(enum) {
                     var str: bun.String = domurl.fileSystemPath();
                     defer str.deref();
                     if (str.isEmpty()) {
-                        JSC.throwInvalidArguments("URL must be a non-empty \"file:\" path", .{}, ctx, exception);
-                        return null;
+                        ctx.throwInvalidArguments("URL must be a non-empty \"file:\" path", .{});
+                        return error.JSError;
                     }
                     arguments.eat();
 
-                    if (!Valid.pathStringLength(str.length(), ctx, exception)) {
-                        return null;
-                    }
+                    try Valid.pathStringLength(str.length(), ctx);
 
                     if (arguments.will_be_async) {
                         var sliced = str.toThreadSafeSlice(allocator);
@@ -1036,73 +1029,67 @@ pub const PathLike = union(enum) {
 };
 
 pub const Valid = struct {
-    pub fn fileDescriptor(fd: i64, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) bool {
+    pub fn fileDescriptor(fd: i64, ctx: JSC.C.JSContextRef) bun.JSError!void {
         if (fd < 0) {
-            JSC.throwInvalidArguments("Invalid file descriptor, must not be negative number", .{}, ctx, exception);
-            return false;
+            ctx.throwInvalidArguments("Invalid file descriptor, must not be negative number", .{});
+            return error.JSError;
         }
 
         const fd_t = if (Environment.isWindows) bun.windows.libuv.uv_file else bun.FileDescriptorInt;
 
         if (fd > std.math.maxInt(fd_t)) {
-            JSC.throwInvalidArguments("Invalid file descriptor, must not be greater than {d}", .{std.math.maxInt(fd_t)}, ctx, exception);
-            return false;
+            ctx.throwInvalidArguments("Invalid file descriptor, must not be greater than {d}", .{std.math.maxInt(fd_t)});
+            return error.JSError;
         }
-
-        return true;
     }
 
-    pub fn pathSlice(zig_str: JSC.ZigString.Slice, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) bool {
+    pub fn pathSlice(zig_str: JSC.ZigString.Slice, ctx: JSC.C.JSContextRef) bun.JSError!void {
         switch (zig_str.len) {
-            0...bun.MAX_PATH_BYTES => return true,
+            0...bun.MAX_PATH_BYTES => return,
             else => {
                 // TODO: should this be an EINVAL?
                 var system_error = bun.sys.Error.fromCode(.NAMETOOLONG, .open).withPath(zig_str.slice()).toSystemError();
                 system_error.syscall = bun.String.dead;
-                exception.* = system_error.toErrorInstance(ctx).asObjectRef();
-                return false;
+                ctx.throwValue(system_error.toErrorInstance(ctx));
+                return error.JSError;
             },
         }
-
         unreachable;
     }
 
-    pub fn pathStringLength(len: usize, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) bool {
+    pub fn pathStringLength(len: usize, ctx: JSC.C.JSContextRef) bun.JSError!void {
         switch (len) {
-            0...bun.MAX_PATH_BYTES => return true,
+            0...bun.MAX_PATH_BYTES => return,
             else => {
                 // TODO: should this be an EINVAL?
                 var system_error = bun.sys.Error.fromCode(.NAMETOOLONG, .open).toSystemError();
                 system_error.syscall = bun.String.dead;
-                exception.* = system_error.toErrorInstance(ctx).asObjectRef();
-                return false;
+                ctx.throwValue(system_error.toErrorInstance(ctx));
+                return error.JSError;
             },
         }
-
         unreachable;
     }
 
-    pub fn pathString(zig_str: JSC.ZigString, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) bool {
-        return pathStringLength(zig_str.len, ctx, exception);
+    pub fn pathString(zig_str: JSC.ZigString, ctx: JSC.C.JSContextRef) bun.JSError!void {
+        return pathStringLength(zig_str.len, ctx);
     }
 
-    pub fn pathBuffer(buffer: Buffer, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) bool {
+    pub fn pathBuffer(buffer: Buffer, ctx: JSC.C.JSContextRef) bun.JSError!void {
         const slice = buffer.slice();
         switch (slice.len) {
             0 => {
-                JSC.throwInvalidArguments("Invalid path buffer: can't be empty", .{}, ctx, exception);
-                return false;
+                ctx.throwInvalidArguments("Invalid path buffer: can't be empty", .{});
+                return error.JSError;
             },
-
             else => {
                 var system_error = bun.sys.Error.fromCode(.NAMETOOLONG, .open).toSystemError();
                 system_error.syscall = bun.String.dead;
-                exception.* = system_error.toErrorInstance(ctx).asObjectRef();
-                return false;
+                ctx.throwValue(system_error.toErrorInstance(ctx));
+                return error.JSError;
             },
-            1...bun.MAX_PATH_BYTES => return true,
+            1...bun.MAX_PATH_BYTES => return,
         }
-
         unreachable;
     }
 };
@@ -1115,10 +1102,9 @@ pub const VectorArrayBuffer = struct {
         return this.value;
     }
 
-    pub fn fromJS(globalObject: *JSC.JSGlobalObject, val: JSC.JSValue, exception: JSC.C.ExceptionRef, allocator: std.mem.Allocator) ?VectorArrayBuffer {
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, val: JSC.JSValue, allocator: std.mem.Allocator) bun.JSError!VectorArrayBuffer {
         if (!val.jsType().isArrayLike()) {
-            JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
-            return null;
+            return globalObject.throwInvalidArguments2("Expected ArrayBufferView[]", .{});
         }
 
         var bufferlist = std.ArrayList(bun.PlatformIOVec).init(allocator);
@@ -1130,13 +1116,11 @@ pub const VectorArrayBuffer = struct {
             const element = val.getIndex(globalObject, @as(u32, @truncate(i)));
 
             if (!element.isCell()) {
-                JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
-                return null;
+                return globalObject.throwInvalidArguments2("Expected ArrayBufferView[]", .{});
             }
 
             const array_buffer = element.asArrayBuffer(globalObject) orelse {
-                JSC.throwInvalidArguments("Expected ArrayBufferView[]", .{}, globalObject, exception);
-                return null;
+                return globalObject.throwInvalidArguments2("Expected ArrayBufferView[]", .{});
             };
 
             const buf = array_buffer.byteSlice();
@@ -1233,8 +1217,8 @@ pub const ArgumentsSlice = struct {
     }
 };
 
-pub fn fileDescriptorFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue, exception: JSC.C.ExceptionRef) ?bun.FileDescriptor {
-    return if (bun.FDImpl.fromJSValidated(value, ctx, exception) catch null) |fd|
+pub fn fileDescriptorFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue) bun.JSError!?bun.FileDescriptor {
+    return if (try bun.FDImpl.fromJSValidated(value, ctx)) |fd|
         fd.encode()
     else
         null;
@@ -1243,7 +1227,7 @@ pub fn fileDescriptorFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue, excepti
 // Node.js docs:
 // > Values can be either numbers representing Unix epoch time in seconds, Dates, or a numeric string like '123456789.0'.
 // > If the value can not be converted to a number, or is NaN, Infinity, or -Infinity, an Error will be thrown.
-pub fn timeLikeFromJS(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue, _: JSC.C.ExceptionRef) ?TimeLike {
+pub fn timeLikeFromJS(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) ?TimeLike {
     if (value.jsType() == .JSDate) {
         const milliseconds = value.getUnixTimestamp();
         if (!std.math.isFinite(milliseconds)) {
@@ -1279,16 +1263,16 @@ pub fn timeLikeFromJS(globalObject: *JSC.JSGlobalObject, value: JSC.JSValue, _:
     };
 }
 
-pub fn modeFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Mode {
+pub fn modeFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue) bun.JSError!?Mode {
     const mode_int = if (value.isNumber()) brk: {
-        const m = validators.validateUint32(ctx, value, "mode", .{}, false) catch return null;
+        const m = try validators.validateUint32(ctx, value, "mode", .{}, false);
         break :brk @as(Mode, @as(u24, @truncate(m)));
     } else brk: {
         if (value.isUndefinedOrNull()) return null;
 
         if (!value.isString()) {
             _ = ctx.throwInvalidArgumentTypeValue("mode", "number", value);
-            return null;
+            return error.JSError;
         }
 
         //        An easier method of constructing the mode is to use a sequence of
@@ -1298,7 +1282,7 @@ pub fn modeFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue, exception: JSC.C.
         //        digit (5 in the example), specifies the permissions for others.
 
         var zig_str = JSC.ZigString.Empty;
-        value.toZigString(&zig_str, ctx.ptr());
+        value.toZigString(&zig_str, ctx);
         var slice = zig_str.slice();
         if (strings.hasPrefix(slice, "0o")) {
             slice = slice[2..];
@@ -1306,8 +1290,8 @@ pub fn modeFromJS(ctx: JSC.C.JSContextRef, value: JSC.JSValue, exception: JSC.C.
 
         break :brk std.fmt.parseInt(Mode, slice, 8) catch {
             var formatter = bun.JSC.ConsoleObject.Formatter{ .globalThis = ctx };
-            exception.* = ctx.ERR_INVALID_ARG_VALUE("The argument 'mode' must be a 32-bit unsigned integer or an octal string. Received {}", .{value.toFmt(&formatter)}).toJS().asObjectRef();
-            return null;
+            ctx.throwValue(ctx.ERR_INVALID_ARG_VALUE("The argument 'mode' must be a 32-bit unsigned integer or an octal string. Received {}", .{value.toFmt(&formatter)}).toJS());
+            return error.JSError;
         };
     };
 
@@ -1365,23 +1349,16 @@ pub const PathOrFileDescriptor = union(Tag) {
         }
     }
 
-    pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, allocator: std.mem.Allocator, exception: JSC.C.ExceptionRef) ?JSC.Node.PathOrFileDescriptor {
+    pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, allocator: std.mem.Allocator) bun.JSError!?JSC.Node.PathOrFileDescriptor {
         const first = arguments.next() orelse return null;
 
-        if (bun.FDImpl.fromJSValidated(first, ctx, exception) catch return null) |fd| {
+        if (try bun.FDImpl.fromJSValidated(first, ctx)) |fd| {
             arguments.eat();
             return JSC.Node.PathOrFileDescriptor{ .fd = fd.encode() };
         }
 
         return JSC.Node.PathOrFileDescriptor{
-            .path = PathLike.fromJSWithAllocator(ctx, arguments, allocator, exception) orelse return null,
-        };
-    }
-
-    pub fn toJS(this: JSC.Node.PathOrFileDescriptor, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) JSC.C.JSValueRef {
-        return switch (this) {
-            .path => |path| path.toJS(ctx, exception),
-            .fd => |fd| bun.FDImpl.decode(fd).toJS(),
+            .path = try PathLike.fromJSWithAllocator(ctx, arguments, allocator) orelse return null,
         };
     }
 };
@@ -1483,11 +1460,11 @@ pub const FileSystemFlags = enum(Mode) {
         .{ "SA+", O_APPEND | O_CREAT | O_RDWR | O_SYNC },
     });
 
-    pub fn fromJS(ctx: JSC.C.JSContextRef, val: JSC.JSValue, exception: JSC.C.ExceptionRef) ?FileSystemFlags {
+    pub fn fromJS(ctx: JSC.C.JSContextRef, val: JSC.JSValue) bun.JSError!?FileSystemFlags {
         if (val.isNumber()) {
             if (!val.isInt32()) {
-                exception.* = ctx.ERR_OUT_OF_RANGE("The value of \"flags\" is out of range. It must be an integer. Received {d}", .{val.asNumber()}).toJS().asObjectRef();
-                return null;
+                ctx.throwValue(ctx.ERR_OUT_OF_RANGE("The value of \"flags\" is out of range. It must be an integer. Received {d}", .{val.asNumber()}).toJS());
+                return error.JSError;
             }
             const number = val.coerce(i32, ctx);
             return @as(FileSystemFlags, @enumFromInt(@as(Mode, @intCast(@max(number, 0)))));
@@ -1497,23 +1474,11 @@ pub const FileSystemFlags = enum(Mode) {
         if (jsType.isStringLike()) {
             const str = val.getZigString(ctx);
             if (str.isEmpty()) {
-                JSC.throwInvalidArguments(
-                    "Expected flags to be a non-empty string. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags",
-                    .{},
-                    ctx,
-                    exception,
-                );
-                return null;
+                return ctx.throwInvalidArguments2("Expected flags to be a non-empty string. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags", .{});
             }
             // it's definitely wrong when the string is super long
             else if (str.len > 12) {
-                JSC.throwInvalidArguments(
-                    "Invalid flag '{any}'. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags",
-                    .{str},
-                    ctx,
-                    exception,
-                );
-                return null;
+                return ctx.throwInvalidArguments2("Invalid flag '{any}'. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags", .{str});
             }
 
             const flags = brk: {
@@ -1537,13 +1502,7 @@ pub const FileSystemFlags = enum(Mode) {
 
                 break :brk map.getWithEql(str, JSC.ZigString.eqlComptime);
             } orelse {
-                JSC.throwInvalidArguments(
-                    "Invalid flag '{any}'. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags",
-                    .{str},
-                    ctx,
-                    exception,
-                );
-                return null;
+                return ctx.throwInvalidArguments2("Invalid flag '{any}'. Learn more at https://nodejs.org/api/fs.html#fs_file_system_flags", .{str});
             };
 
             return @as(FileSystemFlags, @enumFromInt(@as(Mode, @intCast(flags))));
@@ -1669,13 +1628,13 @@ pub fn StatType(comptime Big: bool) type {
         const DOMCallFn = fn (
             *This,
             *JSC.JSGlobalObject,
-        ) callconv(JSC.conv) JSC.JSValue;
+        ) bun.JSError!JSC.JSValue;
         fn domCall(comptime decl: meta.DeclEnum(This)) DOMCallFn {
             return struct {
                 pub fn run(
                     this: *This,
                     _: *JSC.JSGlobalObject,
-                ) callconv(JSC.conv) JSC.JSValue {
+                ) bun.JSError!JSC.JSValue {
                     return @field(This, @tagName(decl))(this);
                 }
             }.run;
@@ -1779,10 +1738,9 @@ pub fn StatType(comptime Big: bool) type {
             };
         }
 
-        pub fn constructor(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) ?*This {
+        pub fn constructor(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!*This {
             if (Big) {
-                globalObject.throwInvalidArguments("BigIntStats is not a constructor", .{});
-                return null;
+                return globalObject.throwInvalidArguments2("BigIntStats is not a constructor", .{});
             }
 
             // dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs
@@ -1885,9 +1843,8 @@ pub const Dirent = struct {
     pub usingnamespace JSC.Codegen.JSDirent;
     pub usingnamespace bun.New(@This());
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(JSC.conv) ?*Dirent {
-        globalObject.throw("Dirent is not a constructor", .{});
-        return null;
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*Dirent {
+        return globalObject.throw2("Dirent is not a constructor", .{});
     }
 
     pub fn toJS(this: *Dirent, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
@@ -1917,49 +1874,49 @@ pub const Dirent = struct {
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.block_device);
     }
     pub fn isCharacterDevice(
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.character_device);
     }
     pub fn isDirectory(
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.directory);
     }
     pub fn isFIFO(
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.named_pipe or this.kind == std.fs.File.Kind.event_port);
     }
     pub fn isFile(
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.file);
     }
     pub fn isSocket(
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.unix_domain_socket);
     }
     pub fn isSymbolicLink(
         this: *Dirent,
         _: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.kind == std.fs.File.Kind.sym_link);
     }
 
diff --git a/src/bun.js/node/util/parse_args.zig b/src/bun.js/node/util/parse_args.zig
index c047fddd258dc9..a7d2c1895da3d5 100644
--- a/src/bun.js/node/util/parse_args.zig
+++ b/src/bun.js/node/util/parse_args.zig
@@ -26,8 +26,6 @@ const isOptionLikeValue = utils.isOptionLikeValue;
 
 const log = bun.Output.scoped(.parseArgs, true);
 
-const ParseArgsError = error{ParseError};
-
 /// Represents a slice of a JSValue array
 const ArgsSlice = struct {
     array: JSValue,
@@ -185,7 +183,7 @@ fn getDefaultArgs(globalThis: *JSGlobalObject) !ArgsSlice {
 }
 
 /// In strict mode, throw for possible usage errors like "--foo --bar" where foo was defined as a string-valued arg
-fn checkOptionLikeValue(globalThis: *JSGlobalObject, token: OptionToken) ParseArgsError!void {
+fn checkOptionLikeValue(globalThis: *JSGlobalObject, token: OptionToken) bun.JSError!void {
     if (!token.inline_value and isOptionLikeValue(token.value.asBunString(globalThis))) {
         const raw_name = OptionToken.RawNameFormatter{ .token = token, .globalThis = globalThis };
 
@@ -208,12 +206,12 @@ fn checkOptionLikeValue(globalThis: *JSGlobalObject, token: OptionToken) ParseAr
             );
         }
         globalThis.vm().throwError(globalThis, err);
-        return error.ParseError;
+        return error.JSError;
     }
 }
 
 /// In strict mode, throw for usage errors.
-fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefinition, allow_positionals: bool, token: OptionToken) ParseArgsError!void {
+fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefinition, allow_positionals: bool, token: OptionToken) bun.JSError!void {
     if (token.option_idx) |option_idx| {
         const option = options[option_idx];
         switch (option.type) {
@@ -230,7 +228,7 @@ fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefiniti
                     globalThis,
                 );
                 globalThis.vm().throwError(globalThis, err);
-                return error.ParseError;
+                return error.JSError;
             },
             .boolean => if (token.value != .jsvalue or !token.value.jsvalue.isUndefined()) {
                 const err = JSC.toTypeError(
@@ -245,7 +243,7 @@ fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefiniti
                     globalThis,
                 );
                 globalThis.vm().throwError(globalThis, err);
-                return error.ParseError;
+                return error.JSError;
             },
         }
     } else {
@@ -263,7 +261,7 @@ fn checkOptionUsage(globalThis: *JSGlobalObject, options: []const OptionDefiniti
             globalThis,
         ));
         globalThis.vm().throwError(globalThis, err);
-        return error.ParseError;
+        return error.JSError;
     }
 }
 
@@ -303,7 +301,7 @@ fn storeOption(globalThis: *JSGlobalObject, option_name: ValueRef, option_value:
     }
 }
 
-fn parseOptionDefinitions(globalThis: *JSGlobalObject, options_obj: JSValue, option_definitions: *std.ArrayList(OptionDefinition)) !void {
+fn parseOptionDefinitions(globalThis: *JSGlobalObject, options_obj: JSValue, option_definitions: *std.ArrayList(OptionDefinition)) bun.JSError!void {
     try validateObject(globalThis, options_obj, "options", .{}, .{});
 
     var iter = JSC.JSPropertyIterator(.{
@@ -330,7 +328,7 @@ fn parseOptionDefinitions(globalThis: *JSGlobalObject, options_obj: JSValue, opt
             if (short_option_str.length() != 1) {
                 const err = JSC.toTypeError(.ERR_INVALID_ARG_VALUE, "options.{s}.short must be a single character", .{option.long_name}, globalThis);
                 globalThis.vm().throwError(globalThis, err);
-                return error.ParseError;
+                return error.JSError;
             }
             option.short_name = short_option_str;
         }
@@ -371,7 +369,10 @@ fn parseOptionDefinitions(globalThis: *JSGlobalObject, options_obj: JSValue, opt
             option.default_value,
         });
 
-        try option_definitions.append(option);
+        option_definitions.append(option) catch {
+            globalThis.throwOutOfMemory();
+            return error.JSError;
+        };
     }
 }
 
@@ -385,8 +386,8 @@ fn tokenizeArgs(
     args: ArgsSlice,
     options: []const OptionDefinition,
     ctx: *T,
-    emitToken: fn (ctx: *T, token: Token) ParseArgsError!void,
-) !void {
+    emitToken: fn (ctx: *T, token: Token) bun.JSError!void,
+) bun.JSError!void {
     const num_args: u32 = args.end - args.start;
     var index: u32 = 0;
     while (index < num_args) : (index += 1) {
@@ -578,7 +579,7 @@ const ParseArgsState = struct {
     /// To reuse JSValue for the "kind" field in the output tokens array ("positional", "option", "option-terminator")
     kinds_jsvalues: [TokenKind.COUNT]?JSValue = [_]?JSValue{null} ** TokenKind.COUNT,
 
-    pub fn handleToken(this: *ParseArgsState, token_generic: Token) ParseArgsError!void {
+    pub fn handleToken(this: *ParseArgsState, token_generic: Token) bun.JSError!void {
         var globalThis = this.globalThis;
 
         switch (token_generic) {
@@ -598,7 +599,7 @@ const ParseArgsState = struct {
                         globalThis,
                     );
                     globalThis.vm().throwError(globalThis, err);
-                    return error.ParseError;
+                    return error.JSError;
                 }
                 const value = token.value.asJSValue(globalThis);
                 this.positionals.push(globalThis, value);
@@ -652,17 +653,10 @@ const ParseArgsState = struct {
 pub fn parseArgs(
     globalThis: *JSGlobalObject,
     callframe: *JSC.CallFrame,
-) JSValue {
+) bun.JSError!JSValue {
     JSC.markBinding(@src());
-    const arguments = callframe.arguments(1).slice();
-    const config = if (arguments.len > 0) arguments[0] else JSValue.undefined;
-    return parseArgsImpl(globalThis, config) catch |err| {
-        // these two types of error will already throw their own js exception
-        if (err != error.ParseError and err != error.InvalidArgument) {
-            globalThis.throwOutOfMemory();
-        }
-        return JSValue.undefined;
-    };
+    const arguments = callframe.argumentsAsArray(1);
+    return parseArgsImpl(globalThis, arguments[0]);
 }
 
 comptime {
@@ -670,7 +664,7 @@ comptime {
     @export(parseArgsFn, .{ .name = "Bun__NodeUtil__jsParseArgs" });
 }
 
-pub fn parseArgsImpl(globalThis: *JSGlobalObject, config_obj: JSValue) !JSValue {
+pub fn parseArgsImpl(globalThis: *JSGlobalObject, config_obj: JSValue) bun.JSError!JSValue {
     //
     // Phase 0: parse the config object
     //
diff --git a/src/bun.js/node/util/validators.zig b/src/bun.js/node/util/validators.zig
index 554f62ddbffc8f..807e9e596884bb 100644
--- a/src/bun.js/node/util/validators.zig
+++ b/src/bun.js/node/util/validators.zig
@@ -18,20 +18,20 @@ pub fn throwErrInvalidArgValue(
     globalThis: *JSGlobalObject,
     comptime fmt: [:0]const u8,
     args: anytype,
-) !void {
+) bun.JSError {
     @setCold(true);
     globalThis.ERR_INVALID_ARG_VALUE(fmt, args).throw();
-    return error.InvalidArgument;
+    return error.JSError;
 }
 
 pub fn throwErrInvalidArgTypeWithMessage(
     globalThis: *JSGlobalObject,
     comptime fmt: [:0]const u8,
     args: anytype,
-) !void {
+) bun.JSError {
     @setCold(true);
     globalThis.ERR_INVALID_ARG_TYPE(fmt, args).throw();
-    return error.InvalidArgument;
+    return error.JSError;
 }
 
 pub fn throwErrInvalidArgType(
@@ -40,84 +40,84 @@ pub fn throwErrInvalidArgType(
     name_args: anytype,
     comptime expected_type: []const u8,
     value: JSValue,
-) !void {
+) bun.JSError {
     @setCold(true);
     const actual_type = getTypeName(globalThis, value);
-    try throwErrInvalidArgTypeWithMessage(globalThis, "\"" ++ name_fmt ++ "\" property must be of type {s}, got {s}", name_args ++ .{ expected_type, actual_type });
+    return throwErrInvalidArgTypeWithMessage(globalThis, "The \"" ++ name_fmt ++ "\" property must be of type {s}, got {s}", name_args ++ .{ expected_type, actual_type });
 }
 
 pub fn throwRangeError(
     globalThis: *JSGlobalObject,
     comptime fmt: [:0]const u8,
     args: anytype,
-) !void {
+) bun.JSError {
     @setCold(true);
     globalThis.ERR_OUT_OF_RANGE(fmt, args).throw();
-    return error.InvalidArgument;
+    return error.JSError;
 }
 
-pub fn validateInteger(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min_value: ?i64, max_value: ?i64) !i64 {
+pub fn validateInteger(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min_value: ?i64, max_value: ?i64) bun.JSError!i64 {
     const min = min_value orelse JSC.MIN_SAFE_INTEGER;
     const max = max_value orelse JSC.MAX_SAFE_INTEGER;
 
     if (!value.isNumber())
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
     if (!value.isAnyInt()) {
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {s}", name_args ++ .{value});
+        return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {s}", name_args ++ .{value});
     }
 
     const num = value.asInt52();
     if (num < min or num > max) {
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {s}", name_args ++ .{ min, max, value });
+        return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {s}", name_args ++ .{ min, max, value });
     }
     return num;
 }
 
-pub fn validateInt32(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min_value: ?i32, max_value: ?i32) !i32 {
+pub fn validateInt32(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min_value: ?i32, max_value: ?i32) bun.JSError!i32 {
     const min = min_value orelse std.math.minInt(i32);
     const max = max_value orelse std.math.maxInt(i32);
     // The defaults for min and max correspond to the limits of 32-bit integers.
     if (!value.isNumber()) {
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
     }
     if (!value.isInt32()) {
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {}", name_args ++ .{value.toFmt(&formatter)});
+        return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {}", name_args ++ .{value.toFmt(&formatter)});
     }
     const num = value.asInt32();
     if (num < min or num > max) {
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {}", name_args ++ .{ min, max, value.toFmt(&formatter) });
+        return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {}", name_args ++ .{ min, max, value.toFmt(&formatter) });
     }
     return num;
 }
 
-pub fn validateUint32(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, greater_than_zero: bool) !u32 {
+pub fn validateUint32(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, greater_than_zero: bool) bun.JSError!u32 {
     if (!value.isNumber()) {
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
     }
     if (!value.isAnyInt()) {
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {}", name_args ++ .{value.toFmt(&formatter)});
+        return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be an integer. Received {}", name_args ++ .{value.toFmt(&formatter)});
     }
     const num: i64 = value.asInt52();
     const min: i64 = if (greater_than_zero) 1 else 0;
     const max: i64 = @intCast(std.math.maxInt(u32));
     if (num < min or num > max) {
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis };
-        try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {}", name_args ++ .{ min, max, value.toFmt(&formatter) });
+        return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {}", name_args ++ .{ min, max, value.toFmt(&formatter) });
     }
     return @truncate(@as(u63, @intCast(num)));
 }
 
-pub fn validateString(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !void {
+pub fn validateString(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!void {
     if (!value.isString())
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "string", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "string", value);
 }
 
-pub fn validateNumber(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min: ?f64, max: ?f64) !f64 {
+pub fn validateNumber(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, min: ?f64, max: ?f64) bun.JSError!f64 {
     if (!value.isNumber())
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "number", value);
 
     const num: f64 = value.asNumber();
     var valid = true;
@@ -132,19 +132,19 @@ pub fn validateNumber(globalThis: *JSGlobalObject, value: JSValue, comptime name
     }
     if (!valid) {
         if (min != null and max != null) {
-            try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {s}", name_args ++ .{ min, max, value });
+            return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d} and <= {d}. Received {s}", name_args ++ .{ min, max, value });
         } else if (min != null) {
-            try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d}. Received {s}", name_args ++ .{ max, value });
+            return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must be >= {d}. Received {s}", name_args ++ .{ max, value });
         } else {
-            try throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must and <= {d}. Received {s}", name_args ++ .{ max, value });
+            return throwRangeError(globalThis, "The value of \"" ++ name_fmt ++ "\" is out of range. It must and <= {d}. Received {s}", name_args ++ .{ max, value });
         }
     }
     return num;
 }
 
-pub fn validateBoolean(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !bool {
+pub fn validateBoolean(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!bool {
     if (!value.isBoolean())
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "boolean", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "boolean", value);
     return value.asBoolean();
 }
 
@@ -154,81 +154,81 @@ pub const ValidateObjectOptions = packed struct {
     allow_function: bool = false,
 };
 
-pub fn validateObject(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, comptime options: ValidateObjectOptions) !void {
+pub fn validateObject(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, comptime options: ValidateObjectOptions) bun.JSError!void {
     if (comptime !options.allow_nullable and !options.allow_array and !options.allow_function) {
         if (value.isNull() or value.jsType().isArray()) {
-            try throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
+            return throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
         }
 
         if (!value.isObject()) {
-            try throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
+            return throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
         }
     } else {
         if (!options.allow_nullable and value.isNull()) {
-            try throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
+            return throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
         }
 
         if (!options.allow_array and value.jsType().isArray()) {
-            try throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
+            return throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
         }
 
         if (!value.isObject() and (!options.allow_function or !value.jsType().isFunction())) {
-            try throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
+            return throwErrInvalidArgType(globalThis, name_fmt, name_args, "object", value);
         }
     }
 }
 
-pub fn validateArray(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, comptime min_length: ?i32) !void {
+pub fn validateArray(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype, comptime min_length: ?i32) bun.JSError!void {
     if (!value.jsType().isArray()) {
         const actual_type = getTypeName(globalThis, value);
-        try throwErrInvalidArgTypeWithMessage(globalThis, "\"" ++ name_fmt ++ "\" property must be an instance of Array, got {s}", name_args ++ .{actual_type});
+        return throwErrInvalidArgTypeWithMessage(globalThis, "The \"" ++ name_fmt ++ "\" property must be an instance of Array, got {s}", name_args ++ .{actual_type});
     }
     if (comptime min_length != null) {
         if (value.getLength(globalThis) < min_length) {
-            try throwErrInvalidArgValue(globalThis, name_fmt ++ " must be longer than {d}", name_args ++ .{min_length});
+            return throwErrInvalidArgValue(globalThis, name_fmt ++ " must be longer than {d}", name_args ++ .{min_length});
         }
     }
 }
 
-pub fn validateStringArray(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !usize {
+pub fn validateStringArray(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!usize {
     try validateArray(globalThis, value, name_fmt, name_args, null);
     var i: usize = 0;
     var iter = value.arrayIterator(globalThis);
     while (iter.next()) |item| {
         if (!item.isString()) {
-            try throwErrInvalidArgType(globalThis, name_fmt ++ "[{d}]", name_args ++ .{i}, "string", value);
+            return throwErrInvalidArgType(globalThis, name_fmt ++ "[{d}]", name_args ++ .{i}, "string", value);
         }
         i += 1;
     }
     return i;
 }
 
-pub fn validateBooleanArray(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !usize {
+pub fn validateBooleanArray(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!usize {
     try validateArray(globalThis, value, name_fmt, name_args, null);
     var i: usize = 0;
     var iter = value.arrayIterator(globalThis);
     while (iter.next()) |item| {
         if (!item.isBoolean()) {
-            try throwErrInvalidArgType(globalThis, name_fmt ++ "[{d}]", name_args ++ .{i}, "boolean", value);
+            return throwErrInvalidArgType(globalThis, name_fmt ++ "[{d}]", name_args ++ .{i}, "boolean", value);
         }
         i += 1;
     }
     return i;
 }
 
-pub fn validateFunction(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !JSValue {
+pub fn validateFunction(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!JSValue {
     if (!value.jsType().isFunction())
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "function", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "function", value);
     return value;
 }
 
-pub fn validateUndefined(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !void {
+pub fn validateUndefined(globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!void {
     if (!value.isUndefined())
-        try throwErrInvalidArgType(globalThis, name_fmt, name_args, "undefined", value);
+        return throwErrInvalidArgType(globalThis, name_fmt, name_args, "undefined", value);
 }
 
-pub fn validateStringEnum(comptime T: type, globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) !T {
-    const str = value.toBunString(globalThis);
+pub fn validateStringEnum(comptime T: type, globalThis: *JSGlobalObject, value: JSValue, comptime name_fmt: string, name_args: anytype) bun.JSError!T {
+    const str = try value.toBunString2(globalThis);
     defer str.deref();
     inline for (@typeInfo(T).Enum.fields) |enum_field| {
         if (str.eqlComptime(enum_field.name))
@@ -242,6 +242,5 @@ pub fn validateStringEnum(comptime T: type, globalThis: *JSGlobalObject, value:
         }
         break :blk out;
     };
-    try throwErrInvalidArgTypeWithMessage(globalThis, name_fmt ++ " must be one of: {s}", name_args ++ .{values_info});
-    return error.InvalidArgument;
+    return throwErrInvalidArgTypeWithMessage(globalThis, name_fmt ++ " must be one of: {s}", name_args ++ .{values_info});
 }
diff --git a/src/bun.js/test/expect.zig b/src/bun.js/test/expect.zig
index d91c9a19286d4e..daca86f1b262dc 100644
--- a/src/bun.js/test/expect.zig
+++ b/src/bun.js/test/expect.zig
@@ -107,9 +107,11 @@ pub const Expect = struct {
             Promise = 8,
             InstanceOf = 9,
 
-            extern fn AsymmetricMatcherConstructorType__fromJS(globalObject: *JSGlobalObject, value: JSValue) u8;
-            pub fn fromJS(globalObject: *JSGlobalObject, value: JSValue) AsymmetricMatcherConstructorType {
-                return @enumFromInt(AsymmetricMatcherConstructorType__fromJS(globalObject, value));
+            extern fn AsymmetricMatcherConstructorType__fromJS(globalObject: *JSGlobalObject, value: JSValue) i8;
+            pub fn fromJS(globalObject: *JSGlobalObject, value: JSValue) bun.JSError!AsymmetricMatcherConstructorType {
+                const result = AsymmetricMatcherConstructorType__fromJS(globalObject, value);
+                if (result == -1) return error.JSError;
+                return @enumFromInt(result);
             }
         };
 
@@ -373,7 +375,7 @@ pub const Expect = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(2).slice();
         const value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
 
@@ -422,12 +424,8 @@ pub const Expect = struct {
         }
     }
 
-    pub fn constructor(
-        globalThis: *JSGlobalObject,
-        _: *CallFrame,
-    ) ?*Expect {
-        globalThis.throw("expect() cannot be called with new", .{});
-        return null;
+    pub fn constructor(globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!*Expect {
+        return globalThis.throw2("expect() cannot be called with new", .{});
     }
 
     // pass here has a leading underscore to avoid name collision with the pass variable in other functions
@@ -435,7 +433,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const arguments_ = callFrame.arguments(1);
@@ -482,7 +480,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const arguments_ = callFrame.arguments(1);
@@ -525,7 +523,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callframe.this();
         const arguments_ = callframe.arguments(2);
@@ -560,7 +558,7 @@ pub const Expect = struct {
 
                 const signature = comptime getSignature("toBe", "<green>expected<r>", false);
                 if (left.deepEquals(right, globalThis) or left.strictDeepEquals(right, globalThis)) {
-                    const fmt = signature ++
+                    const fmt =
                         (if (!has_custom_label) "\n\n<d>If this test should pass, replace \"toBe\" with \"toEqual\" or \"toStrictEqual\"<r>" else "") ++
                         "\n\nExpected: <green>{any}<r>\n" ++
                         "Received: serializes to the same string\n";
@@ -592,7 +590,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callframe.this();
         const arguments_ = callframe.arguments(1);
@@ -667,7 +665,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -753,7 +751,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -851,7 +849,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -907,7 +905,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -980,7 +978,7 @@ pub const Expect = struct {
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1048,7 +1046,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1116,7 +1114,7 @@ pub const Expect = struct {
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1173,7 +1171,7 @@ pub const Expect = struct {
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1240,7 +1238,7 @@ pub const Expect = struct {
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1313,7 +1311,7 @@ pub const Expect = struct {
         this: *Expect,
         globalObject: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalObject);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1380,7 +1378,7 @@ pub const Expect = struct {
         this: *Expect,
         globalThis: *JSGlobalObject,
         callFrame: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const arguments_ = callFrame.arguments(1);
@@ -1482,7 +1480,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeTruthy(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeTruthy(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const value: JSValue = this.getValue(globalThis, thisValue, "toBeTruthy", "") orelse return .zero;
@@ -1514,7 +1512,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeUndefined(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeUndefined(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const value: JSValue = this.getValue(globalThis, thisValue, "toBeUndefined", "") orelse return .zero;
@@ -1544,7 +1542,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeNaN(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeNaN(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1578,7 +1576,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeNull(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeNull(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1607,7 +1605,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeDefined(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeDefined(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1636,7 +1634,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeFalsy(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeFalsy(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1670,7 +1668,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1712,7 +1710,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toStrictEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toStrictEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1749,7 +1747,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toHaveProperty(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toHaveProperty(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1784,7 +1782,7 @@ pub const Expect = struct {
 
         if (pass) {
             received_property = value.getIfPropertyExistsFromPath(globalThis, expected_property_path);
-            pass = !received_property.isEmpty();
+            pass = received_property != .zero;
         }
 
         if (pass and expected_property != null) {
@@ -1799,7 +1797,7 @@ pub const Expect = struct {
         if (not) {
             if (expected_property != null) {
                 const signature = comptime getSignature("toHaveProperty", "<green>path<r><d>, <r><green>value<r>", true);
-                if (!received_property.isEmpty()) {
+                if (received_property != .zero) {
                     this.throw(globalThis, signature, "\n\nExpected path: <green>{any}<r>\n\nExpected value: not <green>{any}<r>\n", .{
                         expected_property_path.toFmt(&formatter),
                         expected_property.?.toFmt(&formatter),
@@ -1818,7 +1816,7 @@ pub const Expect = struct {
 
         if (expected_property != null) {
             const signature = comptime getSignature("toHaveProperty", "<green>path<r><d>, <r><green>value<r>", false);
-            if (!received_property.isEmpty()) {
+            if (received_property != .zero) {
                 // deep equal case
                 const diff_format = DiffFormatter{
                     .received = received_property,
@@ -1844,7 +1842,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeEven(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeEven(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1898,7 +1896,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeGreaterThan(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeGreaterThan(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -1961,7 +1959,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeGreaterThanOrEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeGreaterThanOrEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2024,7 +2022,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeLessThan(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeLessThan(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2087,7 +2085,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeLessThanOrEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeLessThanOrEqual(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2150,7 +2148,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeCloseTo(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeCloseTo(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2233,7 +2231,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeOdd(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeOdd(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2285,7 +2283,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toThrow(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toThrow(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2381,11 +2379,11 @@ pub const Expect = struct {
             const result: JSValue = result_.?;
             var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
 
-            if (expected_value.isEmpty() or expected_value.isUndefined()) {
+            if (expected_value == .zero or expected_value.isUndefined()) {
                 const signature_no_args = comptime getSignature("toThrow", "", true);
                 if (result.toError()) |err| {
-                    const name = err.getTruthyComptime(globalThis, "name") orelse JSValue.undefined;
-                    const message = err.getTruthyComptime(globalThis, "message") orelse JSValue.undefined;
+                    const name = try err.getTruthyComptime(globalThis, "name") orelse JSValue.undefined;
+                    const message = try err.getTruthyComptime(globalThis, "message") orelse JSValue.undefined;
                     const fmt = signature_no_args ++ "\n\nError name: <red>{any}<r>\nError message: <red>{any}<r>\n";
                     globalThis.throwPretty(fmt, .{
                         name.toFmt(&formatter),
@@ -2474,7 +2472,7 @@ pub const Expect = struct {
         }
 
         if (did_throw) {
-            if (expected_value.isEmpty() or expected_value.isUndefined()) return .undefined;
+            if (expected_value == .zero or expected_value.isUndefined()) return .undefined;
 
             const result: JSValue = if (result_.?.toError()) |r|
                 r
@@ -2631,7 +2629,7 @@ pub const Expect = struct {
         var formatter = JSC.ConsoleObject.Formatter{ .globalThis = globalThis, .quote_strings = true };
         const received_line = "Received function did not throw\nReceived value: <red>{any}<r>\n";
 
-        if (expected_value.isEmpty() or expected_value.isUndefined()) {
+        if (expected_value == .zero or expected_value.isUndefined()) {
             const signature = comptime getSignature("toThrow", "", false);
             this.throw(globalThis, signature, "\n\n" ++ received_line, .{result.toFmt(&formatter)});
             return .zero;
@@ -2663,7 +2661,7 @@ pub const Expect = struct {
         this.throw(globalThis, signature, expected_fmt, .{ expected_class, result.toFmt(&formatter) });
         return .zero;
     }
-    pub fn toMatchSnapshot(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toMatchSnapshot(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
         const thisValue = callFrame.this();
         const _arguments = callFrame.arguments(2);
@@ -2778,7 +2776,7 @@ pub const Expect = struct {
         return .undefined;
     }
 
-    pub fn toBeEmpty(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeEmpty(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2856,7 +2854,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeEmptyObject(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeEmptyObject(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2884,7 +2882,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeNil(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeNil(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2911,7 +2909,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeArray(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeArray(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2938,7 +2936,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeArrayOfSize(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeArrayOfSize(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -2982,7 +2980,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeBoolean(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeBoolean(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3009,7 +3007,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeTypeOf(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeTypeOf(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3086,7 +3084,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeTrue(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeTrue(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3113,7 +3111,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeFalse(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeFalse(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3140,7 +3138,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeNumber(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeNumber(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3167,7 +3165,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeInteger(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeInteger(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3194,7 +3192,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeObject(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeObject(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3221,7 +3219,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeFinite(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeFinite(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3254,7 +3252,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBePositive(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBePositive(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3287,7 +3285,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeNegative(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeNegative(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3320,7 +3318,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeWithin(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeWithin(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3383,7 +3381,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toEqualIgnoringWhitespace(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toEqualIgnoringWhitespace(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3465,7 +3463,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeSymbol(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeSymbol(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3492,7 +3490,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeFunction(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeFunction(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3519,7 +3517,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeDate(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeDate(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3546,7 +3544,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeValidDate(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeValidDate(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3574,7 +3572,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeString(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeString(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3601,7 +3599,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toInclude(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toInclude(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3658,7 +3656,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toIncludeRepeated(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toIncludeRepeated(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3769,7 +3767,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toSatisfy(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toSatisfy(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3827,7 +3825,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toStartWith(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toStartWith(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3884,7 +3882,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toEndWith(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toEndWith(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3941,7 +3939,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toBeInstanceOf(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toBeInstanceOf(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer this.postMatch(globalThis);
 
         const thisValue = callFrame.this();
@@ -3988,7 +3986,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toMatch(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toMatch(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         defer this.postMatch(globalThis);
@@ -4052,7 +4050,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toHaveBeenCalled(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveBeenCalled(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
         const thisValue = callframe.this();
         defer this.postMatch(globalThis);
@@ -4085,7 +4083,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toHaveBeenCalledTimes(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveBeenCalledTimes(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const thisValue = callframe.this();
@@ -4128,7 +4126,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toMatchObject(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn toMatchObject(this: *Expect, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         defer this.postMatch(globalThis);
@@ -4192,7 +4190,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toHaveBeenCalledWith(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveBeenCalledWith(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const thisValue = callframe.this();
@@ -4255,7 +4253,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toHaveBeenLastCalledWith(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveBeenLastCalledWith(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const thisValue = callframe.this();
@@ -4317,7 +4315,7 @@ pub const Expect = struct {
         return .zero;
     }
 
-    pub fn toHaveBeenNthCalledWith(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveBeenNthCalledWith(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         JSC.markBinding(@src());
 
         const thisValue = callframe.this();
@@ -4480,11 +4478,11 @@ pub const Expect = struct {
         }
     }
 
-    pub fn toHaveReturned(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveReturned(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return toHaveReturnedTimesFn(this, globalThis, callframe, 1);
     }
 
-    pub fn toHaveReturnedTimes(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toHaveReturnedTimes(this: *Expect, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return toHaveReturnedTimesFn(this, globalThis, callframe, null);
     }
 
@@ -4507,36 +4505,36 @@ pub const Expect = struct {
         return ExpectStatic.create(globalThis, .{ .promise = .rejects });
     }
 
-    pub fn any(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn any(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectAny.call(globalThis, callFrame);
     }
 
-    pub fn anything(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn anything(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectAnything.call(globalThis, callFrame);
     }
 
-    pub fn closeTo(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn closeTo(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectCloseTo.call(globalThis, callFrame);
     }
 
-    pub fn objectContaining(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn objectContaining(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectObjectContaining.call(globalThis, callFrame);
     }
 
-    pub fn stringContaining(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn stringContaining(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectStringContaining.call(globalThis, callFrame);
     }
 
-    pub fn stringMatching(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn stringMatching(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectStringMatching.call(globalThis, callFrame);
     }
 
-    pub fn arrayContaining(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn arrayContaining(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return ExpectArrayContaining.call(globalThis, callFrame);
     }
 
     /// Implements `expect.extend({ ... })`
-    pub fn extend(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn extend(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(1).slice();
 
         if (args.len == 0 or !args[0].isObject()) {
@@ -4569,7 +4567,7 @@ pub const Expect = struct {
                 // Even though they point to the same native functions for all matchers,
                 // multiple instances are created because each instance will hold the matcher_fn as a property
 
-                const wrapper_fn = Bun__JSWrappingFunction__create(globalThis, matcher_name, Expect.applyCustomMatcher, matcher_fn, true);
+                const wrapper_fn = Bun__JSWrappingFunction__create(globalThis, matcher_name, JSC.toJSHostFunction(Expect.applyCustomMatcher), matcher_fn, true);
 
                 expect_proto.put(globalThis, matcher_name, wrapper_fn);
                 expect_constructor.put(globalThis, matcher_name, wrapper_fn);
@@ -4663,12 +4661,7 @@ pub const Expect = struct {
         matcher_context_jsvalue.ensureStillAlive();
 
         // call the custom matcher implementation
-        var result = matcher_fn.call(globalThis, matcher_context_jsvalue, args) catch |err| globalThis.takeException(err);
-        assert(!result.isEmpty());
-        if (result.toError()) |err| {
-            globalThis.throwValue(err);
-            return false;
-        }
+        var result = matcher_fn.call(globalThis, matcher_context_jsvalue, args) catch return false;
         // support for async matcher results
         if (result.asAnyPromise()) |promise| {
             const vm = globalThis.vm();
@@ -4678,7 +4671,7 @@ pub const Expect = struct {
 
             result = promise.result(vm);
             result.ensureStillAlive();
-            assert(!result.isEmpty());
+            assert(result != .zero);
             switch (promise.status(vm)) {
                 .pending => unreachable,
                 .fulfilled => {},
@@ -4734,13 +4727,7 @@ pub const Expect = struct {
             if (comptime Environment.allow_assert)
                 assert(message.isCallable(globalThis.vm())); // checked above
 
-            const message_result = message.callWithGlobalThis(globalThis, &.{}) catch |err|
-                globalThis.takeException(err);
-            assert(!message_result.isEmpty());
-            if (message_result.toError()) |err| {
-                globalThis.throwValue(err);
-                return false;
-            }
+            const message_result = message.callWithGlobalThis(globalThis, &.{}) catch return false;
             if (bun.String.tryFromJS(message_result, globalThis)) |str| {
                 message_text = str;
             } else {
@@ -4768,7 +4755,7 @@ pub const Expect = struct {
 
     /// Function that is run for either `expect.myMatcher()` call or `expect().myMatcher` call,
     /// and we can known which case it is based on if the `callFrame.this()` value is an instance of Expect
-    pub fn applyCustomMatcher(globalThis: *JSGlobalObject, callFrame: *CallFrame) callconv(JSC.conv) JSValue {
+    pub fn applyCustomMatcher(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSC.JSValue {
         defer globalThis.bunVM().autoGarbageCollect();
 
         // retrieve the user-provided matcher function (matcher_fn)
@@ -4830,7 +4817,7 @@ pub const Expect = struct {
 
     pub const addSnapshotSerializer = notImplementedStaticFn;
 
-    pub fn hasAssertions(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn hasAssertions(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         _ = callFrame;
         defer globalThis.bunVM().autoGarbageCollect();
 
@@ -4839,7 +4826,7 @@ pub const Expect = struct {
         return .undefined;
     }
 
-    pub fn assertions(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn assertions(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         defer globalThis.bunVM().autoGarbageCollect();
 
         const arguments_ = callFrame.arguments(1);
@@ -4873,12 +4860,12 @@ pub const Expect = struct {
         return .undefined;
     }
 
-    pub fn notImplementedJSCFn(_: *Expect, globalThis: *JSGlobalObject, _: *CallFrame) JSValue {
+    pub fn notImplementedJSCFn(_: *Expect, globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!JSValue {
         globalThis.throw("Not implemented", .{});
         return .zero;
     }
 
-    pub fn notImplementedStaticFn(globalThis: *JSGlobalObject, _: *CallFrame) JSValue {
+    pub fn notImplementedStaticFn(globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!JSValue {
         globalThis.throw("Not implemented", .{});
         return .zero;
     }
@@ -4898,7 +4885,7 @@ pub const Expect = struct {
         vm.autoGarbageCollect();
     }
 
-    pub fn doUnreachable(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn doUnreachable(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arg = callframe.arguments(1).ptr[0];
 
         if (arg.isEmptyOrUndefinedOrNull()) {
@@ -4976,10 +4963,10 @@ pub const ExpectStatic = struct {
         return .zero;
     }
 
-    fn createAsymmetricMatcherWithFlags(T: anytype, this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    fn createAsymmetricMatcherWithFlags(T: type, this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         //const this: *ExpectStatic = ExpectStatic.fromJS(callFrame.this());
-        const instance_jsvalue = T.call(globalThis, callFrame);
-        if (!instance_jsvalue.isEmpty() and !instance_jsvalue.isAnyError()) {
+        const instance_jsvalue = try T.call(globalThis, callFrame);
+        if (instance_jsvalue != .zero and !instance_jsvalue.isAnyError()) {
             var instance = T.fromJS(instance_jsvalue) orelse {
                 globalThis.throwOutOfMemory();
                 return .zero;
@@ -4989,31 +4976,31 @@ pub const ExpectStatic = struct {
         return instance_jsvalue;
     }
 
-    pub fn anything(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn anything(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectAnything, this, globalThis, callFrame);
     }
 
-    pub fn any(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn any(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectAny, this, globalThis, callFrame);
     }
 
-    pub fn arrayContaining(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn arrayContaining(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectArrayContaining, this, globalThis, callFrame);
     }
 
-    pub fn closeTo(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn closeTo(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectCloseTo, this, globalThis, callFrame);
     }
 
-    pub fn objectContaining(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn objectContaining(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectObjectContaining, this, globalThis, callFrame);
     }
 
-    pub fn stringContaining(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn stringContaining(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectStringContaining, this, globalThis, callFrame);
     }
 
-    pub fn stringMatching(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn stringMatching(this: *ExpectStatic, globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         return createAsymmetricMatcherWithFlags(ExpectStringMatching, this, globalThis, callFrame);
     }
 };
@@ -5029,7 +5016,7 @@ pub const ExpectAnything = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, _: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, _: *CallFrame) bun.JSError!JSValue {
         const anything = globalThis.bunVM().allocator.create(ExpectAnything) catch {
             globalThis.throwOutOfMemory();
             return .zero;
@@ -5057,7 +5044,7 @@ pub const ExpectStringMatching = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(1).slice();
 
         if (args.len == 0 or (!args[0].isString() and !args[0].isRegExp())) {
@@ -5094,7 +5081,7 @@ pub const ExpectCloseTo = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(2).slice();
 
         if (args.len == 0 or !args[0].isNumber()) {
@@ -5141,7 +5128,7 @@ pub const ExpectObjectContaining = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(1).slice();
 
         if (args.len == 0 or !args[0].isObject()) {
@@ -5178,7 +5165,7 @@ pub const ExpectStringContaining = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(1).slice();
 
         if (args.len == 0 or !args[0].isString()) {
@@ -5209,19 +5196,16 @@ pub const ExpectAny = struct {
 
     flags: Expect.Flags = .{},
 
-    pub fn finalize(
-        this: *ExpectAny,
-    ) callconv(.C) void {
+    pub fn finalize(this: *ExpectAny) callconv(.C) void {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const _arguments = callFrame.arguments(1);
         const arguments: []const JSValue = _arguments.ptr[0.._arguments.len];
 
         if (arguments.len == 0) {
-            globalThis.throw("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.", .{});
-            return .zero;
+            return globalThis.throw2("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.", .{});
         }
 
         const constructor = arguments[0];
@@ -5229,19 +5213,19 @@ pub const ExpectAny = struct {
         if (!constructor.isConstructor()) {
             const fmt = "<d>expect.<r>any<d>(<r>constructor<d>)<r>\n\nExpected a constructor\n";
             globalThis.throwPretty(fmt, .{});
-            return .zero;
+            return error.JSError;
         }
 
-        const asymmetric_matcher_constructor_type = Expect.Flags.AsymmetricMatcherConstructorType.fromJS(globalThis, constructor);
+        const asymmetric_matcher_constructor_type = try Expect.Flags.AsymmetricMatcherConstructorType.fromJS(globalThis, constructor);
 
         // I don't think this case is possible, but just in case!
         if (globalThis.hasException()) {
-            return .zero;
+            return error.JSError;
         }
 
         var any = globalThis.bunVM().allocator.create(ExpectAny) catch {
             globalThis.throwOutOfMemory();
-            return .zero;
+            return error.JSError;
         };
         any.* = .{
             .flags = .{
@@ -5272,7 +5256,7 @@ pub const ExpectArrayContaining = struct {
         VirtualMachine.get().allocator.destroy(this);
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(1).slice();
 
         if (args.len == 0 or !args[0].jsType().isArray()) {
@@ -5396,7 +5380,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
         return Expect.executeCustomMatcher(globalThis, matcher_name, matcher_fn, matcher_args.items, this.flags, true);
     }
 
-    pub fn asymmetricMatch(this: *ExpectCustomAsymmetricMatcher, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn asymmetricMatch(this: *ExpectCustomAsymmetricMatcher, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(1).slice();
         const received_value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
         const matched = execute(this, callframe.this(), globalThis, received_value);
@@ -5430,7 +5414,7 @@ pub const ExpectCustomAsymmetricMatcher = struct {
         return false;
     }
 
-    pub fn toAsymmetricMatcher(this: *ExpectCustomAsymmetricMatcher, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn toAsymmetricMatcher(this: *ExpectCustomAsymmetricMatcher, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         var stack_fallback = std.heap.stackFallback(512, globalThis.allocator());
         var mutable_string = bun.MutableString.init2048(stack_fallback.get()) catch {
             globalThis.throwOutOfMemory();
@@ -5483,7 +5467,7 @@ pub const ExpectMatcherContext = struct {
         return JSValue.false;
     }
 
-    pub fn equals(_: *ExpectMatcherContext, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn equals(_: *ExpectMatcherContext, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         var arguments = callframe.arguments(3);
         if (arguments.len < 2) {
             globalThis.throw("expect.extends matcher: this.util.equals expects at least 2 arguments", .{});
@@ -5552,25 +5536,25 @@ pub const ExpectMatcherUtils = struct {
         };
     }
 
-    pub fn stringify(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn stringify(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(1).slice();
         const value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
         return printValueCatched(globalThis, value, null);
     }
 
-    pub fn printExpected(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn printExpected(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(1).slice();
         const value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
         return printValueCatched(globalThis, value, "<green>");
     }
 
-    pub fn printReceived(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn printReceived(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(1).slice();
         const value = if (arguments.len < 1) JSValue.jsUndefined() else arguments[0];
         return printValueCatched(globalThis, value, "<red>");
     }
 
-    pub fn matcherHint(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn matcherHint(_: *ExpectMatcherUtils, globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(4).slice();
 
         if (arguments.len == 0 or !arguments[0].isString()) {
@@ -5639,8 +5623,8 @@ pub const ExpectMatcherUtils = struct {
 
 // Extract the matcher_fn from a JSCustomExpectMatcherFunction instance
 inline fn getCustomMatcherFn(thisValue: JSValue, globalThis: *JSGlobalObject) ?JSValue {
-    var matcher_fn = Bun__JSWrappingFunction__getWrappedFunction(thisValue, globalThis);
-    return if (matcher_fn.isEmpty()) null else matcher_fn;
+    const matcher_fn = Bun__JSWrappingFunction__getWrappedFunction(thisValue, globalThis);
+    return if (matcher_fn == .zero) null else matcher_fn;
 }
 
 /// JSValue.zero is used to indicate it was not a JSMockFunction
diff --git a/src/bun.js/test/jest.zig b/src/bun.js/test/jest.zig
index 950c339c5e4599..43b0bee0a0dd54 100644
--- a/src/bun.js/test/jest.zig
+++ b/src/bun.js/test/jest.zig
@@ -276,40 +276,31 @@ pub const TestRunner = struct {
 pub const Jest = struct {
     pub var runner: ?*TestRunner = null;
 
-    fn globalHook(comptime name: string) JSC.JSHostFunctionType {
+    fn globalHook(comptime name: string) JSC.JSHostZigFunction {
         return struct {
-            pub fn appendGlobalFunctionCallback(
-                globalThis: *JSGlobalObject,
-                callframe: *CallFrame,
-            ) callconv(JSC.conv) JSValue {
+            pub fn appendGlobalFunctionCallback(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
                 const the_runner = runner orelse {
-                    globalThis.throw("Cannot use " ++ name ++ "() outside of the test runner. Run \"bun test\" to run tests.", .{});
-                    return .zero;
+                    return globalThis.throw2("Cannot use " ++ name ++ "() outside of the test runner. Run \"bun test\" to run tests.", .{});
                 };
 
                 const arguments = callframe.arguments(2);
                 if (arguments.len < 1) {
-                    globalThis.throwNotEnoughArguments("callback", 1, arguments.len);
-                    return .zero;
+                    return globalThis.throwNotEnoughArguments("callback", 1, arguments.len);
                 }
 
                 const function = arguments.ptr[0];
                 if (function.isEmptyOrUndefinedOrNull() or !function.isCallable(globalThis.vm())) {
                     globalThis.throwInvalidArgumentType(name, "callback", "function");
-                    return .zero;
+                    return error.JSError;
                 }
 
                 if (function.getLength(globalThis) > 0) {
-                    globalThis.throw("done() callback is not implemented in global hooks yet. Please make your function take no arguments", .{});
-                    return .zero;
+                    return globalThis.throw2("done() callback is not implemented in global hooks yet. Please make your function take no arguments", .{});
                 }
 
                 function.protect();
-                @field(the_runner.global_callbacks, name).append(
-                    bun.default_allocator,
-                    function,
-                ) catch unreachable;
-                return JSValue.jsUndefined();
+                @field(the_runner.global_callbacks, name).append(bun.default_allocator, function) catch unreachable;
+                return .undefined;
             }
         }.appendGlobalFunctionCallback;
     }
@@ -526,7 +517,7 @@ pub const Jest = struct {
     pub fn call(
         globalObject: *JSGlobalObject,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const vm = globalObject.bunVM();
         if (vm.is_in_preload or runner == null) {
             return Bun__Jest__testPreloadObject(globalObject);
@@ -554,7 +545,7 @@ pub const Jest = struct {
         return Bun__Jest__testModuleObject(globalObject);
     }
 
-    fn jsSetDefaultTimeout(globalObject: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    fn jsSetDefaultTimeout(globalObject: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(1).slice();
         if (arguments.len < 1 or !arguments[0].isNumber()) {
             globalObject.throw("setTimeout() expects a number (milliseconds)", .{});
@@ -604,39 +595,39 @@ pub const TestScope = struct {
         actual: u32 = 0,
     };
 
-    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "test()", true, .pass);
     }
 
-    pub fn only(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn only(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "test.only()", true, .only);
     }
 
-    pub fn skip(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn skip(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "test.skip()", true, .skip);
     }
 
-    pub fn todo(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn todo(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "test.todo()", true, .todo);
     }
 
-    pub fn each(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn each(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createEach(globalThis, callframe, "test.each()", "each", true);
     }
 
-    pub fn callIf(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn callIf(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createIfScope(globalThis, callframe, "test.if()", "if", TestScope, .pass);
     }
 
-    pub fn skipIf(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn skipIf(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createIfScope(globalThis, callframe, "test.skipIf()", "skipIf", TestScope, .skip);
     }
 
-    pub fn todoIf(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn todoIf(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createIfScope(globalThis, callframe, "test.todoIf()", "todoIf", TestScope, .todo);
     }
 
-    pub fn onReject(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn onReject(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         debug("onReject", .{});
         const arguments = callframe.arguments(2);
         const err = arguments.ptr[0];
@@ -648,7 +639,7 @@ pub const TestScope = struct {
     }
     const jsOnReject = JSC.toJSHostFunction(onReject);
 
-    pub fn onResolve(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn onResolve(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         debug("onResolve", .{});
         const arguments = callframe.arguments(2);
         var task: *TestRunnerTask = arguments.ptr[1].asPromisePtr(TestRunnerTask);
@@ -661,7 +652,7 @@ pub const TestScope = struct {
     pub fn onDone(
         globalThis: *JSGlobalObject,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const function = callframe.callee();
         const args = callframe.arguments(1);
         defer globalThis.bunVM().autoGarbageCollect();
@@ -778,7 +769,7 @@ pub const TestScope = struct {
                     task.promise_state = .pending;
                     switch (promise) {
                         .normal => |p| {
-                            _ = p.asValue(vm.global).then(vm.global, task, jsOnResolve, jsOnReject);
+                            _ = p.asValue(vm.global).then(vm.global, task, onResolve, onReject);
                             return .{ .pending = {} };
                         },
                         else => unreachable,
@@ -890,24 +881,20 @@ pub const DescribeScope = struct {
 
     pub threadlocal var active: ?*DescribeScope = null;
 
-    const CallbackFn = JSC.JSHostFunctionType;
+    const CallbackFn = JSC.JSHostZigFunction;
 
     fn createCallback(comptime hook: LifecycleHook) CallbackFn {
         return struct {
-            pub fn run(
-                globalThis: *JSGlobalObject,
-                callframe: *CallFrame,
-            ) callconv(JSC.conv) JSValue {
+            pub fn run(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSC.JSValue {
                 const arguments = callframe.arguments(2);
                 if (arguments.len < 1) {
-                    globalThis.throwNotEnoughArguments("callback", 1, arguments.len);
-                    return .zero;
+                    return globalThis.throwNotEnoughArguments("callback", 1, arguments.len);
                 }
 
                 const cb = arguments.ptr[0];
                 if (!cb.isObject() or !cb.isCallable(globalThis.vm())) {
                     globalThis.throwInvalidArgumentType(@tagName(hook), "callback", "function");
-                    return .zero;
+                    return error.JSError;
                 }
 
                 cb.protect();
@@ -920,7 +907,7 @@ pub const DescribeScope = struct {
     pub fn onDone(
         ctx: js.JSContextRef,
         callframe: *CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const function = callframe.callee();
         const args = callframe.arguments(1);
         defer ctx.bunVM().autoGarbageCollect();
@@ -1074,35 +1061,35 @@ pub const DescribeScope = struct {
         return null;
     }
 
-    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn call(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "describe()", false, .pass);
     }
 
-    pub fn only(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn only(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "describe.only()", false, .only);
     }
 
-    pub fn skip(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn skip(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "describe.skip()", false, .skip);
     }
 
-    pub fn todo(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn todo(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createScope(globalThis, callframe, "describe.todo()", false, .todo);
     }
 
-    pub fn each(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn each(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createEach(globalThis, callframe, "describe.each()", "each", false);
     }
 
-    pub fn callIf(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn callIf(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createIfScope(globalThis, callframe, "describe.if()", "if", DescribeScope, .pass);
     }
 
-    pub fn skipIf(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn skipIf(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createIfScope(globalThis, callframe, "describe.skipIf()", "skipIf", DescribeScope, .skip);
     }
 
-    pub fn todoIf(globalThis: *JSGlobalObject, callframe: *CallFrame) JSValue {
+    pub fn todoIf(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
         return createIfScope(globalThis, callframe, "describe.todoIf()", "todoIf", DescribeScope, .todo);
     }
 
@@ -1125,10 +1112,10 @@ pub const DescribeScope = struct {
 
             if (result.asAnyPromise()) |prom| {
                 globalObject.bunVM().waitForPromise(prom);
-                switch (prom.status(globalObject.ptr().vm())) {
+                switch (prom.status(globalObject.vm())) {
                     .fulfilled => {},
                     else => {
-                        _ = globalObject.bunVM().unhandledRejection(globalObject, prom.result(globalObject.ptr().vm()), prom.asValue(globalObject));
+                        _ = globalObject.bunVM().unhandledRejection(globalObject, prom.result(globalObject.vm()), prom.asValue(globalObject));
                         return .undefined;
                     },
                 }
@@ -1228,27 +1215,11 @@ pub const DescribeScope = struct {
     }
 
     const ScopeStack = ObjectPool(std.ArrayListUnmanaged(*DescribeScope), null, true, 16);
-
-    // pub fn runBeforeAll(this: *DescribeScope, ctx: js.JSContextRef, exception: js.ExceptionRef) bool {
-    //     var scopes = ScopeStack.get(default_allocator);
-    //     defer scopes.release();
-    //     scopes.data.clearRetainingCapacity();
-    //     var cur: ?*DescribeScope = this;
-    //     while (cur) |scope| {
-    //         scopes.data.append(default_allocator, this) catch unreachable;
-    //         cur = scope.parent;
-    //     }
-
-    //     // while (scopes.data.popOrNull()) |scope| {
-    //     //     scope.
-    //     // }
-    // }
-
 };
 
-pub fn wrapTestFunction(comptime name: []const u8, comptime func: anytype) DescribeScope.CallbackFn {
+pub fn wrapTestFunction(comptime name: []const u8, comptime func: JSC.JSHostZigFunction) DescribeScope.CallbackFn {
     return struct {
-        pub fn wrapped(globalThis: *JSGlobalObject, callframe: *CallFrame) callconv(JSC.conv) JSValue {
+        pub fn wrapped(globalThis: *JSGlobalObject, callframe: *CallFrame) bun.JSError!JSValue {
             if (Jest.runner == null) {
                 globalThis.throw("Cannot use " ++ name ++ "() outside of the test runner. Run \"bun test\" to run tests.", .{});
                 return .zero;
@@ -1878,7 +1849,10 @@ fn consumeArg(
 ) !void {
     const allocator = getAllocator(globalThis);
     if (should_write) {
-        const owned_slice = arg.toSliceOrNull(globalThis) orelse return error.Failed;
+        const owned_slice = arg.toSliceOrNull(globalThis) orelse {
+            bun.assert(globalThis.hasException());
+            return error.JSError;
+        };
         defer owned_slice.deinit();
         array_list.appendSlice(allocator, owned_slice.slice()) catch bun.outOfMemory();
     } else {
@@ -1902,7 +1876,7 @@ fn formatLabel(globalThis: *JSGlobalObject, label: string, function_args: []JSVa
 
             switch (label[idx + 1]) {
                 's' => {
-                    try consumeArg(globalThis, !current_arg.isEmpty() and current_arg.jsType().isString(), &idx, &args_idx, &list, &current_arg, "%s");
+                    try consumeArg(globalThis, current_arg != .zero and current_arg.jsType().isString(), &idx, &args_idx, &list, &current_arg, "%s");
                 },
                 'i' => {
                     try consumeArg(globalThis, current_arg.isAnyInt(), &idx, &args_idx, &list, &current_arg, "%i");
@@ -1961,7 +1935,7 @@ pub const EachData = struct { strong: JSC.Strong, is_test: bool };
 fn eachBind(
     globalThis: *JSGlobalObject,
     callframe: *CallFrame,
-) JSValue {
+) bun.JSError!JSValue {
     const signature = "eachBind";
     const callee = callframe.callee();
     const arguments = callframe.arguments(3);
@@ -2069,7 +2043,7 @@ fn eachBind(
                 ""
             else
                 (description.toSlice(globalThis, allocator).cloneIfNeeded(allocator) catch unreachable).slice();
-            const formattedLabel = formatLabel(globalThis, label, function_args, test_idx) catch return .zero;
+            const formattedLabel = try formatLabel(globalThis, label, function_args, test_idx);
 
             const tag = parent.tag;
 
@@ -2144,7 +2118,7 @@ inline fn createEach(
     }
 
     var array = args[0];
-    if (array.isEmpty() or !array.jsType().isArray()) {
+    if (array == .zero or !array.jsType().isArray()) {
         globalThis.throwPretty("{s} expects an array", .{signature});
         return .zero;
     }
diff --git a/src/bun.js/test/pretty_format.zig b/src/bun.js/test/pretty_format.zig
index 874158774fa793..a15e4133cedf46 100644
--- a/src/bun.js/test/pretty_format.zig
+++ b/src/bun.js/test/pretty_format.zig
@@ -294,7 +294,7 @@ pub const JestPrettyFormat = struct {
         // For detecting circular references
         pub const Visited = struct {
             const ObjectPool = @import("../../pool.zig").ObjectPool;
-            pub const Map = std.AutoHashMap(JSValue.Type, void);
+            pub const Map = std.AutoHashMap(JSValue, void);
             pub const Pool = ObjectPool(
                 Map,
                 struct {
@@ -915,7 +915,7 @@ pub const JestPrettyFormat = struct {
                     this.map = this.map_node.?.data;
                 }
 
-                const entry = this.map.getOrPut(@intFromEnum(value)) catch unreachable;
+                const entry = this.map.getOrPut(value) catch unreachable;
                 if (entry.found_existing) {
                     writer.writeAll(comptime Output.prettyFmt("<r><cyan>[Circular]<r>", enable_ansi_colors));
                     return;
@@ -924,7 +924,7 @@ pub const JestPrettyFormat = struct {
 
             defer {
                 if (comptime Format.canHaveCircularReferences()) {
-                    _ = this.map.remove(@intFromEnum(value));
+                    _ = this.map.remove(value);
                 }
             }
 
diff --git a/src/bun.js/webcore.zig b/src/bun.js/webcore.zig
index 9f8aa0bf24cb0a..f26b0a1d5bd1dc 100644
--- a/src/bun.js/webcore.zig
+++ b/src/bun.js/webcore.zig
@@ -23,7 +23,7 @@ pub const Lifetime = enum {
 };
 
 /// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-alert
-fn alert(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+fn alert(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1).slice();
     var output = bun.Output.writer();
     const has_message = arguments.len != 0;
@@ -73,7 +73,7 @@ fn alert(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(
     return .undefined;
 }
 
-fn confirm(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+fn confirm(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1).slice();
     var output = bun.Output.writer();
     const has_message = arguments.len != 0;
@@ -211,7 +211,7 @@ pub const Prompt = struct {
     pub fn call(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(3).slice();
         var state = std.heap.stackFallback(2048, bun.default_allocator);
         const allocator = state.get();
@@ -370,7 +370,7 @@ pub const Crypto = struct {
         salt: JSC.Node.StringOrBuffer,
         keylen_value: JSC.JSValue,
         options: ?JSC.JSValue,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const password_string = password.slice();
         const salt_string = salt.slice();
 
@@ -404,22 +404,17 @@ pub const Crypto = struct {
                 return .zero;
             }
 
-            if (options_value.getTruthy(globalThis, "cost") orelse options_value.getTruthy(globalThis, "N")) |N_value| {
+            if (try options_value.getTruthy(globalThis, "cost") orelse try options_value.getTruthy(globalThis, "N")) |N_value| {
                 if (cost != null) return throwInvalidParameter(globalThis);
                 const N_int = N_value.to(i64);
                 if (N_int < 0 or !N_value.isNumber()) {
-                    return throwInvalidParams(
-                        globalThis,
-                        .RangeError,
-                        "Invalid scrypt params\n\n N must be a positive integer\n",
-                        .{},
-                    );
+                    return throwInvalidParams(globalThis, .RangeError, "Invalid scrypt params\n\n N must be a positive integer\n", .{});
                 } else if (N_int != 0) {
                     cost = @as(usize, @intCast(N_int));
                 }
             }
 
-            if (options_value.getTruthy(globalThis, "blockSize") orelse options_value.getTruthy(globalThis, "r")) |r_value| {
+            if (try options_value.getTruthy(globalThis, "blockSize") orelse try options_value.getTruthy(globalThis, "r")) |r_value| {
                 if (blockSize != null) return throwInvalidParameter(globalThis);
                 const r_int = r_value.to(i64);
                 if (r_int < 0 or !r_value.isNumber()) {
@@ -434,7 +429,7 @@ pub const Crypto = struct {
                 }
             }
 
-            if (options_value.getTruthy(globalThis, "parallelization") orelse options_value.getTruthy(globalThis, "p")) |p_value| {
+            if (try options_value.getTruthy(globalThis, "parallelization") orelse try options_value.getTruthy(globalThis, "p")) |p_value| {
                 if (parallelization != null) return throwInvalidParameter(globalThis);
                 const p_int = p_value.to(i64);
                 if (p_int < 0 or !p_value.isNumber()) {
@@ -449,7 +444,7 @@ pub const Crypto = struct {
                 }
             }
 
-            if (options_value.getTruthy(globalThis, "maxmem")) |value| {
+            if (try options_value.getTruthy(globalThis, "maxmem")) |value| {
                 const p_int = value.to(i64);
                 if (p_int < 0 or !value.isNumber()) {
                     return throwInvalidParams(
@@ -554,7 +549,7 @@ pub const Crypto = struct {
         _: *@This(),
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(2).slice();
 
         if (arguments.len < 2) {
@@ -604,7 +599,7 @@ pub const Crypto = struct {
         _: *@This(),
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(1).slice();
         if (arguments.len == 0) {
             globalThis.throwInvalidArguments("Expected typed array but got nothing", .{});
@@ -655,7 +650,7 @@ pub const Crypto = struct {
         _: *@This(),
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const str, var bytes = bun.String.createUninitialized(.latin1, 36);
         defer str.deref();
 
@@ -665,10 +660,11 @@ pub const Crypto = struct {
         return str.toJS(globalThis);
     }
 
-    pub export fn Bun__randomUUIDv7(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) JSC.JSValue {
+    comptime {
+        const Bun__randomUUIDv7 = JSC.toJSHostFunction(Bun__randomUUIDv7_);
+        @export(Bun__randomUUIDv7, .{ .name = "Bun__randomUUIDv7" });
+    }
+    pub fn Bun__randomUUIDv7_(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments = callframe.argumentsUndef(2).slice();
 
         var encoding_value: JSC.JSValue = .undefined;
@@ -743,9 +739,8 @@ pub const Crypto = struct {
         return str.toJS(globalThis);
     }
 
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) ?*Crypto {
-        globalThis.throw("Crypto is not constructable", .{});
-        return null;
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*Crypto {
+        return globalThis.throw2("Crypto is not constructable", .{});
     }
 
     pub export fn CryptoObject__create(globalThis: *JSC.JSGlobalObject) JSC.JSValue {
@@ -770,8 +765,11 @@ pub const Crypto = struct {
 
 comptime {
     if (!JSC.is_bindgen) {
-        @export(alert, .{ .name = "WebCore__alert" });
-        @export(Prompt.call, .{ .name = "WebCore__prompt" });
-        @export(confirm, .{ .name = "WebCore__confirm" });
+        const js_alert = JSC.toJSHostFunction(alert);
+        @export(js_alert, .{ .name = "WebCore__alert" });
+        const js_prompt = JSC.toJSHostFunction(Prompt.call);
+        @export(js_prompt, .{ .name = "WebCore__prompt" });
+        const js_confirm = JSC.toJSHostFunction(confirm);
+        @export(js_confirm, .{ .name = "WebCore__confirm" });
     }
 }
diff --git a/src/bun.js/webcore/ObjectURLRegistry.zig b/src/bun.js/webcore/ObjectURLRegistry.zig
index 10a30fdab8d2bf..6708087ec18975 100644
--- a/src/bun.js/webcore/ObjectURLRegistry.zig
+++ b/src/bun.js/webcore/ObjectURLRegistry.zig
@@ -89,15 +89,17 @@ pub fn has(this: *ObjectURLRegistry, pathname: []const u8) bool {
     return this.map.contains(uuid);
 }
 
-export fn Bun__createObjectURL(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+comptime {
+    const Bun__createObjectURL = JSC.toJSHostFunction(Bun__createObjectURL_);
+    @export(Bun__createObjectURL, .{ .name = "Bun__createObjectURL" });
+}
+fn Bun__createObjectURL_(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1);
     if (arguments.len < 1) {
-        globalObject.throwNotEnoughArguments("createObjectURL", 1, arguments.len);
-        return JSC.JSValue.undefined;
+        return globalObject.throwNotEnoughArguments("createObjectURL", 1, arguments.len);
     }
     const blob = arguments.ptr[0].as(JSC.WebCore.Blob) orelse {
-        globalObject.throwInvalidArguments("createObjectURL expects a Blob object", .{});
-        return JSC.JSValue.undefined;
+        return globalObject.throwInvalidArguments2("createObjectURL expects a Blob object", .{});
     };
     const registry = ObjectURLRegistry.singleton();
     const uuid = registry.register(globalObject.bunVM(), blob);
@@ -105,15 +107,17 @@ export fn Bun__createObjectURL(globalObject: *JSC.JSGlobalObject, callframe: *JS
     return str.transferToJS(globalObject);
 }
 
-export fn Bun__revokeObjectURL(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+comptime {
+    const Bun__revokeObjectURL = JSC.toJSHostFunction(Bun__revokeObjectURL_);
+    @export(Bun__revokeObjectURL, .{ .name = "Bun__revokeObjectURL" });
+}
+fn Bun__revokeObjectURL_(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1);
     if (arguments.len < 1) {
-        globalObject.throwNotEnoughArguments("revokeObjectURL", 1, arguments.len);
-        return JSC.JSValue.undefined;
+        return globalObject.throwNotEnoughArguments("revokeObjectURL", 1, arguments.len);
     }
     if (!arguments.ptr[0].isString()) {
-        globalObject.throwInvalidArguments("revokeObjectURL expects a string", .{});
-        return JSC.JSValue.undefined;
+        return globalObject.throwInvalidArguments2("revokeObjectURL expects a string", .{});
     }
     const str = arguments.ptr[0].toBunString(globalObject);
     if (!str.hasPrefixComptime("blob:")) {
@@ -132,7 +136,11 @@ export fn Bun__revokeObjectURL(globalObject: *JSC.JSGlobalObject, callframe: *JS
     return JSC.JSValue.undefined;
 }
 
-export fn jsFunctionResolveObjectURL(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+comptime {
+    const jsFunctionResolveObjectURL = JSC.toJSHostFunction(jsFunctionResolveObjectURL_);
+    @export(jsFunctionResolveObjectURL, .{ .name = "jsFunctionResolveObjectURL" });
+}
+fn jsFunctionResolveObjectURL_(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(1);
 
     // Errors are ignored.
@@ -161,12 +169,6 @@ export fn jsFunctionResolveObjectURL(globalObject: *JSC.JSGlobalObject, callfram
     return blob orelse JSC.JSValue.undefined;
 }
 
-comptime {
-    _ = &Bun__createObjectURL;
-    _ = &Bun__revokeObjectURL;
-    _ = &jsFunctionResolveObjectURL;
-}
-
 pub const specifier_len = "blob:".len + UUID.stringLength;
 
 pub fn isBlobURL(url: []const u8) bool {
diff --git a/src/bun.js/webcore/blob.zig b/src/bun.js/webcore/blob.zig
index 3b5322436cef32..4b4153ca6bd395 100644
--- a/src/bun.js/webcore/blob.zig
+++ b/src/bun.js/webcore/blob.zig
@@ -48,8 +48,8 @@ const PathOrBlob = union(enum) {
     path: JSC.Node.PathOrFileDescriptor,
     blob: Blob,
 
-    pub fn fromJSNoCopy(ctx: js.JSContextRef, args: *JSC.Node.ArgumentsSlice, exception: js.ExceptionRef) ?PathOrBlob {
-        if (JSC.Node.PathOrFileDescriptor.fromJS(ctx, args, bun.default_allocator, exception)) |path| {
+    pub fn fromJSNoCopy(ctx: js.JSContextRef, args: *JSC.Node.ArgumentsSlice) bun.JSError!?PathOrBlob {
+        if (try JSC.Node.PathOrFileDescriptor.fromJS(ctx, args, bun.default_allocator)) |path| {
             return PathOrBlob{
                 .path = path,
             };
@@ -364,7 +364,7 @@ pub const Blob = struct {
             },
         };
 
-        _onStructuredCloneSerialize(this, Writer, writer) catch return .zero;
+        try _onStructuredCloneSerialize(this, Writer, writer);
     }
 
     pub fn onStructuredCloneTransfer(
@@ -520,7 +520,16 @@ pub const Blob = struct {
         var buffer_stream = std.io.fixedBufferStream(ptr[0..total_length]);
         const reader = buffer_stream.reader();
 
-        return _onStructuredCloneDeserialize(globalThis, @TypeOf(reader), reader) catch return .zero;
+        return _onStructuredCloneDeserialize(globalThis, @TypeOf(reader), reader) catch |err| switch (err) {
+            error.EndOfStream, error.TooSmall, error.InvalidValue => {
+                globalThis.throw("Blob.onStructuredCloneDeserialize failed", .{});
+                return .zero;
+            },
+            error.OutOfMemory => {
+                globalThis.throwOutOfMemory();
+                return .zero;
+            },
+        };
     }
 
     const URLSearchParamsConverter = struct {
@@ -866,7 +875,7 @@ pub const Blob = struct {
                 }
             }
 
-            return JSC.JSPromise.resolvedPromiseValue(ctx.ptr(), JSC.JSValue.jsNumber(0));
+            return JSC.JSPromise.resolvedPromiseValue(ctx, JSC.JSValue.jsNumber(0));
         }
 
         const source_type = std.meta.activeTag(source_blob.store.?.data);
@@ -877,7 +886,7 @@ pub const Blob = struct {
             });
 
             if (comptime Environment.isWindows) {
-                var promise = JSPromise.create(ctx.ptr());
+                var promise = JSPromise.create(ctx);
                 const promise_value = promise.asValue(ctx);
                 promise_value.ensureStillAlive();
                 write_file_promise.promise.strong.set(ctx, promise_value);
@@ -901,9 +910,9 @@ pub const Blob = struct {
                 WriteFilePromise.run,
                 mkdirp_if_not_exists,
             ) catch unreachable;
-            var task = WriteFile.WriteFileTask.createOnJSThread(bun.default_allocator, ctx.ptr(), file_copier) catch bun.outOfMemory();
+            var task = WriteFile.WriteFileTask.createOnJSThread(bun.default_allocator, ctx, file_copier) catch bun.outOfMemory();
             // Defer promise creation until we're just about to schedule the task
-            var promise = JSC.JSPromise.create(ctx.ptr());
+            var promise = JSC.JSPromise.create(ctx);
             const promise_value = promise.asValue(ctx);
             write_file_promise.promise.strong.set(ctx, promise_value);
             promise_value.ensureStillAlive();
@@ -928,7 +937,7 @@ pub const Blob = struct {
 
                 destination_blob.offset,
                 destination_blob.size,
-                ctx.ptr(),
+                ctx,
                 mkdirp_if_not_exists,
             ) catch unreachable;
             file_copier.schedule();
@@ -942,15 +951,14 @@ pub const Blob = struct {
             clone.allocator = bun.default_allocator;
             const cloned = Blob.new(clone);
             cloned.allocator = bun.default_allocator;
-            return JSPromise.resolvedPromiseValue(ctx.ptr(), cloned.toJS(ctx));
+            return JSPromise.resolvedPromiseValue(ctx, cloned.toJS(ctx));
         } else if (destination_type == .bytes and source_type == .file) {
             var fake_call_frame: [8]JSC.JSValue = undefined;
             @memset(@as([*]u8, @ptrCast(&fake_call_frame))[0..@sizeOf(@TypeOf(fake_call_frame))], 0);
-            const blob_value =
-                source_blob.getSlice(ctx, @as(*JSC.CallFrame, @ptrCast(&fake_call_frame)));
+            const blob_value = source_blob.getSlice(ctx, @as(*JSC.CallFrame, @ptrCast(&fake_call_frame))) catch .zero; // TODO:
 
             return JSPromise.resolvedPromiseValue(
-                ctx.ptr(),
+                ctx,
                 blob_value,
             );
         }
@@ -961,20 +969,14 @@ pub const Blob = struct {
     pub fn writeFile(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(3).slice();
         var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments);
         defer args.deinit();
-        var exception_ = [1]JSC.JSValueRef{null};
-        var exception = &exception_;
 
         // accept a path or a blob
-        var path_or_blob = PathOrBlob.fromJSNoCopy(globalThis, &args, exception) orelse {
-            if (exception[0] != null) {
-                globalThis.throwValue(exception[0].?.value());
-            } else {
-                globalThis.throwInvalidArguments("Bun.write expects a path, file descriptor or a blob", .{});
-            }
+        var path_or_blob = (try PathOrBlob.fromJSNoCopy(globalThis, &args)) orelse {
+            globalThis.throwInvalidArguments("Bun.write expects a path, file descriptor or a blob", .{});
             return .zero;
         };
         defer {
@@ -1017,7 +1019,7 @@ pub const Blob = struct {
 
         if (args.nextEat()) |options_object| {
             if (options_object.isObject()) {
-                if (options_object.getTruthy(globalThis, "createPath")) |create_directory| {
+                if (try options_object.getTruthy(globalThis, "createPath")) |create_directory| {
                     if (!create_directory.isBoolean()) {
                         globalThis.throwInvalidArgumentType("write", "options.createPath", "boolean");
                         return .zero;
@@ -1420,10 +1422,16 @@ pub const Blob = struct {
         return blob.is_jsdom_file;
     }
 
-    pub export fn JSDOMFile__construct(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) ?*Blob {
+    export fn JSDOMFile__construct(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) ?*Blob {
+        return JSDOMFile__construct_(globalThis, callframe) catch |err| switch (err) {
+            error.JSError => null,
+            error.OutOfMemory => {
+                globalThis.throwOutOfMemory();
+                return null;
+            },
+        };
+    }
+    pub fn JSDOMFile__construct_(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!?*Blob {
         JSC.markBinding(@src());
         const allocator = bun.default_allocator;
         var blob: Blob = undefined;
@@ -1443,15 +1451,16 @@ pub const Blob = struct {
             };
             defer name_value_str.deref();
 
-            blob = get(globalThis, args[0], false, true) catch |err| {
-                if (!globalThis.hasException()) {
-                    if (err == error.InvalidArguments) {
-                        globalThis.throwInvalidArguments("new File(bits, name) expects iterable as the first argument", .{});
-                        return null;
-                    }
+            blob = get(globalThis, args[0], false, true) catch |err| switch (err) {
+                error.JSError => return null,
+                error.OutOfMemory => {
                     globalThis.throwOutOfMemory();
-                }
-                return null;
+                    return null;
+                },
+                error.InvalidArguments => {
+                    globalThis.throwInvalidArguments("new Blob() expects an Array", .{});
+                    return null;
+                },
             };
 
             if (blob.store) |store_| {
@@ -1499,7 +1508,7 @@ pub const Blob = struct {
                     }
                 }
 
-                if (options.getTruthy(globalThis, "lastModified")) |last_modified| {
+                if (try options.getTruthy(globalThis, "lastModified")) |last_modified| {
                     set_last_modified = true;
                     blob.last_modified = last_modified.coerce(f64, globalThis);
                 }
@@ -1551,29 +1560,21 @@ pub const Blob = struct {
     comptime {
         if (!JSC.is_bindgen) {
             _ = JSDOMFile__hasInstance;
-            _ = JSDOMFile__construct;
         }
     }
 
     pub fn constructBunFile(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var vm = globalObject.bunVM();
         const arguments = callframe.arguments(2).slice();
         var args = JSC.Node.ArgumentsSlice.init(vm, arguments);
         defer args.deinit();
-        var exception_ = [1]JSC.JSValueRef{null};
-        const exception = &exception_;
-
-        var path = JSC.Node.PathOrFileDescriptor.fromJS(globalObject, &args, bun.default_allocator, exception) orelse {
-            if (exception_[0] == null) {
-                globalObject.throwInvalidArguments("Expected file path string or file descriptor", .{});
-            } else {
-                globalObject.throwValue(exception_[0].?.value());
-            }
 
-            return .undefined;
+        var path = (try JSC.Node.PathOrFileDescriptor.fromJS(globalObject, &args, bun.default_allocator)) orelse {
+            globalObject.throwInvalidArguments("Expected file path string or file descriptor", .{});
+            return .zero;
         };
         defer path.deinitAndUnprotect();
 
@@ -1583,7 +1584,7 @@ pub const Blob = struct {
             const opts = arguments[1];
 
             if (opts.isObject()) {
-                if (opts.getTruthy(globalObject, "type")) |file_type| {
+                if (try opts.getTruthy(globalObject, "type")) |file_type| {
                     inner: {
                         if (file_type.isString()) {
                             var allocator = bun.default_allocator;
@@ -1604,7 +1605,7 @@ pub const Blob = struct {
                         }
                     }
                 }
-                if (opts.getTruthy(globalObject, "lastModified")) |last_modified| {
+                if (try opts.getTruthy(globalObject, "lastModified")) |last_modified| {
                     blob.last_modified = last_modified.coerce(f64, globalObject);
                 }
             }
@@ -3259,7 +3260,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const thisValue = callframe.this();
         if (Blob.streamGetCached(thisValue)) |cached| {
             return cached;
@@ -3302,7 +3303,7 @@ pub const Blob = struct {
     pub fn toStreamWithOffset(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const this = callframe.this().as(Blob) orelse @panic("this is not a Blob");
         const args = callframe.arguments(1).slice();
 
@@ -3326,7 +3327,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.getTextClone(globalThis);
     }
 
@@ -3354,7 +3355,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         return this.getJSONShare(globalThis);
     }
 
@@ -3392,7 +3393,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return this.getArrayBufferClone(globalThis);
     }
 
@@ -3410,7 +3411,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return this.getBytesClone(globalThis);
     }
 
@@ -3428,7 +3429,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const store = this.store;
         if (store) |st| st.ref();
         defer if (store) |st| st.deref();
@@ -3460,7 +3461,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         return JSC.JSPromise.resolvedPromiseValue(globalThis, this.getExistsSync());
     }
 
@@ -3468,23 +3469,20 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var arguments_ = callframe.arguments(1);
         var arguments = arguments_.ptr[0..arguments_.len];
 
         if (!arguments.ptr[0].isEmptyOrUndefinedOrNull() and !arguments.ptr[0].isObject()) {
-            globalThis.throwInvalidArguments("options must be an object or undefined", .{});
-            return JSValue.jsUndefined();
+            return globalThis.throwInvalidArguments2("options must be an object or undefined", .{});
         }
 
         var store = this.store orelse {
-            globalThis.throwInvalidArguments("Blob is detached", .{});
-            return JSValue.jsUndefined();
+            return globalThis.throwInvalidArguments2("Blob is detached", .{});
         };
 
         if (store.data != .file) {
-            globalThis.throwInvalidArguments("Blob is read-only", .{});
-            return JSValue.jsUndefined();
+            return globalThis.throwInvalidArguments2("Blob is read-only", .{});
         }
 
         if (Environment.isWindows) {
@@ -3502,8 +3500,7 @@ pub const Blob = struct {
                         break :brk result;
                     },
                     .err => |err| {
-                        globalThis.throwValue(err.withPath(path).toJSC(globalThis));
-                        return JSValue.jsUndefined();
+                        return globalThis.throwValue2(err.withPath(path).toJSC(globalThis));
                     },
                 }
                 unreachable;
@@ -3535,20 +3532,16 @@ pub const Blob = struct {
             if (is_stdout_or_stderr) {
                 switch (sink.writer.startSync(fd, false)) {
                     .err => |err| {
-                        globalThis.throwValue(err.toJSC(globalThis));
                         sink.deref();
-
-                        return JSC.JSValue.zero;
+                        return globalThis.throwValue2(err.toJSC(globalThis));
                     },
                     else => {},
                 }
             } else {
                 switch (sink.writer.start(fd, true)) {
                     .err => |err| {
-                        globalThis.throwValue(err.toJSC(globalThis));
                         sink.deref();
-
-                        return JSC.JSValue.zero;
+                        return globalThis.throwValue2(err.toJSC(globalThis));
                     },
                     else => {},
                 }
@@ -3581,16 +3574,14 @@ pub const Blob = struct {
         };
 
         if (arguments.len > 0 and arguments.ptr[0].isObject()) {
-            stream_start = JSC.WebCore.StreamStart.fromJSWithTag(globalThis, arguments[0], .FileSink);
+            stream_start = try JSC.WebCore.StreamStart.fromJSWithTag(globalThis, arguments[0], .FileSink);
             stream_start.FileSink.input_path = input_path;
         }
 
         switch (sink.start(stream_start)) {
             .err => |err| {
-                globalThis.vm().throwError(globalThis, err.toJSC(globalThis));
                 sink.deref();
-
-                return JSC.JSValue.zero;
+                return globalThis.vm().throwError2(globalThis, err.toJSC(globalThis));
             },
             else => {},
         }
@@ -3607,7 +3598,7 @@ pub const Blob = struct {
         this: *Blob,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const allocator = bun.default_allocator;
         var arguments_ = callframe.arguments(3);
         var args = arguments_.ptr[0..arguments_.len];
@@ -3952,10 +3943,7 @@ pub const Blob = struct {
         }
     }
 
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) ?*Blob {
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Blob {
         const allocator = bun.default_allocator;
         var blob: Blob = undefined;
         var arguments = callframe.arguments(2);
@@ -3967,14 +3955,9 @@ pub const Blob = struct {
                 blob = Blob.init(empty, allocator, globalThis);
             },
             else => {
-                blob = get(globalThis, args[0], false, true) catch |err| {
-                    if (err == error.InvalidArguments) {
-                        globalThis.throwInvalidArguments("new Blob() expects an Array", .{});
-                        return null;
-                    }
-                    if (!globalThis.hasException())
-                        globalThis.throwOutOfMemory();
-                    return null;
+                blob = get(globalThis, args[0], false, true) catch |err| switch (err) {
+                    error.OutOfMemory, error.JSError => |e| return e,
+                    error.InvalidArguments => return globalThis.throwInvalidArguments2("new Blob() expects an Array", .{}),
                 };
 
                 if (args.len > 1) {
@@ -4527,24 +4510,26 @@ pub const Blob = struct {
         return toFormDataWithBytes(this, global, @constCast(view_), lifetime);
     }
 
+    const FromJsError = bun.JSError || error{InvalidArguments};
+
     pub inline fn get(
         global: *JSGlobalObject,
         arg: JSValue,
         comptime move: bool,
         comptime require_array: bool,
-    ) anyerror!Blob {
+    ) FromJsError!Blob {
         return fromJSMovable(global, arg, move, require_array);
     }
 
-    pub inline fn fromJSMove(global: *JSGlobalObject, arg: JSValue) anyerror!Blob {
+    pub inline fn fromJSMove(global: *JSGlobalObject, arg: JSValue) FromJsError!Blob {
         return fromJSWithoutDeferGC(global, arg, true, false);
     }
 
-    pub inline fn fromJSClone(global: *JSGlobalObject, arg: JSValue) anyerror!Blob {
+    pub inline fn fromJSClone(global: *JSGlobalObject, arg: JSValue) FromJsError!Blob {
         return fromJSWithoutDeferGC(global, arg, false, true);
     }
 
-    pub inline fn fromJSCloneOptionalArray(global: *JSGlobalObject, arg: JSValue) anyerror!Blob {
+    pub inline fn fromJSCloneOptionalArray(global: *JSGlobalObject, arg: JSValue) FromJsError!Blob {
         return fromJSWithoutDeferGC(global, arg, false, false);
     }
 
@@ -4553,7 +4538,7 @@ pub const Blob = struct {
         arg: JSValue,
         comptime move: bool,
         comptime require_array: bool,
-    ) anyerror!Blob {
+    ) FromJsError!Blob {
         const FromJSFunction = if (comptime move and !require_array)
             fromJSMove
         else if (!require_array)
@@ -4569,7 +4554,7 @@ pub const Blob = struct {
         arg: JSValue,
         comptime move: bool,
         comptime require_array: bool,
-    ) anyerror!Blob {
+    ) FromJsError!Blob {
         var current = arg;
         if (current.isUndefinedOrNull()) {
             return Blob{ .globalThis = global };
diff --git a/src/bun.js/webcore/body.zig b/src/bun.js/webcore/body.zig
index 3948775827da6b..a40a03a526ccef 100644
--- a/src/bun.js/webcore/body.zig
+++ b/src/bun.js/webcore/body.zig
@@ -530,10 +530,7 @@ pub const Body = struct {
             }
         }
 
-        pub fn fromJS(
-            globalThis: *JSGlobalObject,
-            value: JSValue,
-        ) ?Value {
+        pub fn fromJS(globalThis: *JSGlobalObject, value: JSValue) bun.JSError!Value {
             value.ensureStillAlive();
 
             if (value.isEmptyOrUndefinedOrNull()) {
@@ -579,8 +576,7 @@ pub const Body = struct {
                         .InternalBlob = .{
                             .bytes = std.ArrayList(u8){
                                 .items = bun.default_allocator.dupe(u8, bytes) catch {
-                                    globalThis.vm().throwError(globalThis, ZigString.static("Failed to clone ArrayBufferView").toErrorInstance(globalThis));
-                                    return null;
+                                    return globalThis.vm().throwError2(globalThis, ZigString.static("Failed to clone ArrayBufferView").toErrorInstance(globalThis));
                                 },
                                 .capacity = bytes.len,
                                 .allocator = bun.default_allocator,
@@ -615,8 +611,7 @@ pub const Body = struct {
 
             if (JSC.WebCore.ReadableStream.fromJS(value, globalThis)) |readable| {
                 if (readable.isDisturbed(globalThis)) {
-                    globalThis.throw("ReadableStream has already been used", .{});
-                    return null;
+                    return globalThis.throw2("ReadableStream has already been used", .{});
                 }
 
                 switch (readable.ptr) {
@@ -643,14 +638,13 @@ pub const Body = struct {
                 .Blob = Blob.get(globalThis, value, true, false) catch |err| {
                     if (!globalThis.hasException()) {
                         if (err == error.InvalidArguments) {
-                            globalThis.throwInvalidArguments("Expected an Array", .{});
-                            return null;
+                            return globalThis.throwInvalidArguments2("Expected an Array", .{});
                         }
 
-                        globalThis.throwInvalidArguments("Invalid Body object", .{});
+                        return globalThis.throwInvalidArguments2("Invalid Body object", .{});
                     }
 
-                    return null;
+                    return error.JSError;
                 },
             };
         }
@@ -1091,10 +1085,10 @@ pub const Body = struct {
     pub fn extract(
         globalThis: *JSGlobalObject,
         value: JSValue,
-    ) ?Body {
+    ) bun.JSError!Body {
         var body = Body{ .value = Value{ .Null = {} } };
 
-        body.value = Value.fromJS(globalThis, value) orelse return null;
+        body.value = try Value.fromJS(globalThis, value);
         if (body.value == .Blob)
             assert(body.value.Blob.allocator == null); // owned by Body
 
@@ -1108,7 +1102,7 @@ pub fn BodyMixin(comptime Type: type) type {
             this: *Type,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             var value: *Body.Value = this.getBodyValue();
             if (value.* == .Used) {
                 return handleBodyAlreadyUsed(globalObject);
@@ -1174,7 +1168,7 @@ pub fn BodyMixin(comptime Type: type) type {
             this: *Type,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             var value: *Body.Value = this.getBodyValue();
             if (value.* == .Used) {
                 return handleBodyAlreadyUsed(globalObject);
@@ -1204,7 +1198,7 @@ pub fn BodyMixin(comptime Type: type) type {
             this: *Type,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             var value: *Body.Value = this.getBodyValue();
 
             if (value.* == .Used) {
@@ -1232,7 +1226,7 @@ pub fn BodyMixin(comptime Type: type) type {
             this: *Type,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             var value: *Body.Value = this.getBodyValue();
 
             if (value.* == .Used) {
@@ -1258,7 +1252,7 @@ pub fn BodyMixin(comptime Type: type) type {
             this: *Type,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             var value: *Body.Value = this.getBodyValue();
 
             if (value.* == .Used) {
@@ -1308,7 +1302,7 @@ pub fn BodyMixin(comptime Type: type) type {
             this: *Type,
             globalObject: *JSC.JSGlobalObject,
             callframe: *JSC.CallFrame,
-        ) JSC.JSValue {
+        ) bun.JSError!JSC.JSValue {
             return getBlobWithThisValue(this, globalObject, callframe.this());
         }
 
@@ -1510,14 +1504,14 @@ pub const BodyValueBufferer = struct {
         }
     }
 
-    pub fn onResolveStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+    pub fn onResolveStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         var args = callframe.arguments(2);
         var sink: *@This() = args.ptr[args.len - 1].asPromisePtr(@This());
         sink.handleResolveStream(true);
         return JSValue.jsUndefined();
     }
 
-    pub fn onRejectStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+    pub fn onRejectStream(_: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const args = callframe.arguments(2);
         var sink = args.ptr[args.len - 1].asPromisePtr(@This());
         const err = args.ptr[0];
@@ -1706,12 +1700,10 @@ pub const BodyValueBufferer = struct {
 
     comptime {
         if (!JSC.is_bindgen) {
-            @export(onResolveStream, .{
-                .name = Export[0].symbol_name,
-            });
-            @export(onRejectStream, .{
-                .name = Export[1].symbol_name,
-            });
+            const jsonResolveStream = JSC.toJSHostFunction(onResolveStream);
+            @export(jsonResolveStream, .{ .name = Export[0].symbol_name });
+            const jsonRejectStream = JSC.toJSHostFunction(onRejectStream);
+            @export(jsonRejectStream, .{ .name = Export[1].symbol_name });
         }
     }
 };
diff --git a/src/bun.js/webcore/encoding.zig b/src/bun.js/webcore/encoding.zig
index 9dffa73e92a0ff..91a79f8acfdb2c 100644
--- a/src/bun.js/webcore/encoding.zig
+++ b/src/bun.js/webcore/encoding.zig
@@ -195,7 +195,7 @@ pub const TextEncoder = struct {
             return .undefined;
         }
 
-        if (array.isEmpty()) {
+        if (array == .zero) {
             array = JSC.JSValue.createUninitializedUint8Array(globalThis, length);
             array.ensureStillAlive();
             @memcpy(array.asArrayBuffer(globalThis).?.ptr[0..length], buf_to_use[0..length]);
@@ -416,15 +416,14 @@ pub const TextEncoderStreamEncoder = struct {
         this.destroy();
     }
 
-    pub fn constructor(_: *JSGlobalObject, _: *JSC.CallFrame) ?*TextEncoderStreamEncoder {
+    pub fn constructor(_: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!*TextEncoderStreamEncoder {
         return TextEncoderStreamEncoder.new(.{});
     }
 
-    pub fn encode(this: *TextEncoderStreamEncoder, globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSValue {
+    pub fn encode(this: *TextEncoderStreamEncoder, globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSValue {
         const arguments = callFrame.arguments(1).slice();
         if (arguments.len == 0) {
-            globalObject.throwNotEnoughArguments("TextEncoderStreamEncoder.encode", 1, arguments.len);
-            return .zero;
+            return globalObject.throwNotEnoughArguments("TextEncoderStreamEncoder.encode", 1, arguments.len);
         }
 
         const str: ZigString = (arguments[0].toStringOrNull(globalObject) orelse return .zero).getZigString(globalObject);
@@ -590,7 +589,7 @@ pub const TextEncoderStreamEncoder = struct {
         }
     }
 
-    pub fn flush(this: *TextEncoderStreamEncoder, globalObject: *JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn flush(this: *TextEncoderStreamEncoder, globalObject: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         return flushBody(this, globalObject);
     }
 
@@ -640,25 +639,7 @@ pub const TextDecoder = struct {
     ) JSC.JSValue {
         return JSC.JSValue.jsBoolean(this.ignore_bom);
     }
-    // pub fn setIgnoreBOM(
-    //     this: *TextDecoder,
-    //     _: *JSC.JSGlobalObject,
-    // )  JSC.JSValue {
-    //     this.ignore_bom = JSValue.fromRef(this.ignore_bom).toBoolean();
-    //     return true;
-    // }
 
-    // pub fn setFatal(
-    //     this: *TextDecoder,
-    //     _: js.JSContextRef,
-    //     _: js.JSValueRef,
-    //     _: js.JSStringRef,
-    //     value: JSC.C.JSValueRef,
-    //     _: js.ExceptionRef,
-    // ) bool {
-    //     this.fatal = JSValue.fromRef(value).toBoolean();
-    //     return true;
-    // }
     pub fn getFatal(
         this: *TextDecoder,
         _: *JSC.JSGlobalObject,
@@ -778,7 +759,7 @@ pub const TextDecoder = struct {
         return .{ output, saw_error };
     }
 
-    pub fn decode(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn decode(this: *TextDecoder, globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         const arguments = callframe.arguments(2).slice();
 
         const input_slice = input_slice: {
@@ -921,10 +902,7 @@ pub const TextDecoder = struct {
         }
     }
 
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) ?*TextDecoder {
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*TextDecoder {
         var args_ = callframe.arguments(2);
         var arguments: []const JSC.JSValue = args_.ptr[0..args_.len];
 
@@ -939,31 +917,27 @@ pub const TextDecoder = struct {
                 if (EncodingLabel.which(str.slice())) |label| {
                     decoder.encoding = label;
                 } else {
-                    globalThis.throwInvalidArguments("Unsupported encoding label \"{s}\"", .{str.slice()});
-                    return null;
+                    return globalThis.throwInvalidArguments2("Unsupported encoding label \"{s}\"", .{str.slice()});
                 }
             } else if (arguments[0].isUndefined()) {
                 // default to utf-8
                 decoder.encoding = EncodingLabel.@"UTF-8";
             } else {
-                globalThis.throwInvalidArguments("TextDecoder(encoding) label is invalid", .{});
-                return null;
+                return globalThis.throwInvalidArguments2("TextDecoder(encoding) label is invalid", .{});
             }
 
             if (arguments.len >= 2) {
                 const options = arguments[1];
 
                 if (!options.isObject()) {
-                    globalThis.throwInvalidArguments("TextDecoder(options) is invalid", .{});
-                    return null;
+                    return globalThis.throwInvalidArguments2("TextDecoder(options) is invalid", .{});
                 }
 
                 if (options.get(globalThis, "fatal")) |fatal| {
                     if (fatal.isBoolean()) {
                         decoder.fatal = fatal.asBoolean();
                     } else {
-                        globalThis.throwInvalidArguments("TextDecoder(options) fatal is invalid. Expected boolean value", .{});
-                        return null;
+                        return globalThis.throwInvalidArguments2("TextDecoder(options) fatal is invalid. Expected boolean value", .{});
                     }
                 }
 
@@ -971,8 +945,7 @@ pub const TextDecoder = struct {
                     if (ignoreBOM.isBoolean()) {
                         decoder.ignore_bom = ignoreBOM.asBoolean();
                     } else {
-                        globalThis.throwInvalidArguments("TextDecoder(options) ignoreBOM is invalid. Expected boolean value", .{});
-                        return null;
+                        return globalThis.throwInvalidArguments2("TextDecoder(options) ignoreBOM is invalid. Expected boolean value", .{});
                     }
                 }
             }
@@ -1259,6 +1232,71 @@ pub const Encoder = struct {
         }
     }
 
+    /// Assumes `input` is not owned memory.
+    ///
+    /// Can be run on non-JavaScript threads.
+    ///
+    /// This is like toString(), but it returns a WTFString instead of a JSString*.
+    pub fn toWTFString(input: []const u8, encoding: JSC.Node.Encoding) bun.String {
+        if (input.len == 0)
+            return bun.String.empty;
+
+        switch (encoding) {
+            .ascii => {
+                const str, const chars = bun.String.createUninitialized(.latin1, input.len);
+                strings.copyLatin1IntoASCII(chars, input);
+                return str;
+            },
+            .latin1 => {
+                const str, const chars = bun.String.createUninitialized(.latin1, input.len);
+                @memcpy(chars, input);
+                return str;
+            },
+            .buffer, .utf8 => {
+                const converted = strings.toUTF16Alloc(bun.default_allocator, input, false, false) catch return bun.String.dead;
+                if (converted) |utf16| {
+                    return bun.String.createExternalGloballyAllocated(.utf16, utf16);
+                }
+
+                // If we get here, it means we can safely assume the string is 100% ASCII characters
+                // For this, we rely on WebKit to manage the memory.
+                return bun.String.createLatin1(input);
+            },
+            .ucs2, .utf16le => {
+                // Avoid incomplete characters
+                if (input.len / 2 == 0) return bun.String.empty;
+
+                const output, const chars = bun.String.createUninitialized(.utf16, input.len / 2);
+                var output_bytes = std.mem.sliceAsBytes(chars);
+                output_bytes[output_bytes.len - 1] = 0;
+
+                @memcpy(output_bytes, input[0..output_bytes.len]);
+                return output;
+            },
+
+            .hex => {
+                const str, const chars = bun.String.createUninitialized(.latin1, input.len * 2);
+
+                const wrote = strings.encodeBytesToHex(chars, input);
+                bun.assert(wrote == chars.len);
+                return str;
+            },
+
+            .base64url => {
+                const out, const chars = bun.String.createUninitialized(.latin1, bun.base64.urlSafeEncodeLen(input));
+                _ = bun.base64.encodeURLSafe(chars, input);
+                return out;
+            },
+
+            .base64 => {
+                const to_len = bun.base64.encodeLen(input);
+                const to = bun.default_allocator.alloc(u8, to_len) catch return bun.String.dead;
+                const wrote = bun.base64.encode(to, input);
+                return bun.String.createExternalGloballyAllocated(.latin1, to[0..wrote]);
+            },
+        }
+    }
+
     pub fn writeU8(input: [*]const u8, len: usize, to_ptr: [*]u8, to_len: usize, comptime encoding: JSC.Node.Encoding) !usize {
         if (len == 0 or to_len == 0)
             return 0;
diff --git a/src/bun.js/webcore/request.zig b/src/bun.js/webcore/request.zig
index bbd04d239bf0cf..1a296026b2b4a8 100644
--- a/src/bun.js/webcore/request.zig
+++ b/src/bun.js/webcore/request.zig
@@ -524,15 +524,10 @@ pub const Request = struct {
         url,
     };
 
-    pub fn constructInto(
-        globalThis: *JSC.JSGlobalObject,
-        arguments: []const JSC.JSValue,
-    ) ?Request {
+    pub fn constructInto(globalThis: *JSC.JSGlobalObject, arguments: []const JSC.JSValue) bun.JSError!Request {
         var success = false;
         const vm = globalThis.bunVM();
-        const body = vm.initRequestBodyValue(.{ .Null = {} }) catch {
-            return null;
-        };
+        const body = try vm.initRequestBodyValue(.{ .Null = {} });
         var req = Request{
             .body = body,
         };
@@ -547,11 +542,9 @@ pub const Request = struct {
         }
 
         if (arguments.len == 0) {
-            globalThis.throw("Failed to construct 'Request': 1 argument required, but only 0 present.", .{});
-            return null;
+            return globalThis.throw2("Failed to construct 'Request': 1 argument required, but only 0 present.", .{});
         } else if (arguments[0].isEmptyOrUndefinedOrNull() or !arguments[0].isCell()) {
-            globalThis.throw("Failed to construct 'Request': expected non-empty string or object, got undefined", .{});
-            return null;
+            return globalThis.throw2("Failed to construct 'Request': expected non-empty string or object, got undefined", .{});
         }
 
         const url_or_object = arguments[0];
@@ -565,16 +558,13 @@ pub const Request = struct {
             url_or_object.as(JSC.DOMURL) != null;
 
         if (is_first_argument_a_url) {
-            const str = bun.String.tryFromJS(arguments[0], globalThis) orelse {
-                return null;
-            };
+            const str = try bun.String.fromJS2(arguments[0], globalThis);
             req.url = str;
 
             if (!req.url.isEmpty())
                 fields.insert(.url);
         } else if (!url_or_object_type.isObject()) {
-            globalThis.throw("Failed to construct 'Request': expected non-empty string or object", .{});
-            return null;
+            return globalThis.throw2("Failed to construct 'Request': expected non-empty string or object", .{});
         }
 
         const values_to_try_ = [_]JSValue{
@@ -610,7 +600,7 @@ pub const Request = struct {
                             fields.insert(.headers);
                         }
 
-                        if (globalThis.hasException()) return null;
+                        if (globalThis.hasException()) return error.JSError;
                     }
 
                     if (!fields.contains(.body)) {
@@ -618,7 +608,7 @@ pub const Request = struct {
                             .Null, .Empty, .Used => {},
                             else => {
                                 req.body.value = request.body.value.clone(globalThis);
-                                if (globalThis.hasException()) return null;
+                                if (globalThis.hasException()) return error.JSError;
                                 fields.insert(.body);
                             },
                         }
@@ -655,19 +645,17 @@ pub const Request = struct {
                         }
                     }
 
-                    if (globalThis.hasException()) return null;
+                    if (globalThis.hasException()) return error.JSError;
                 }
             }
 
             if (!fields.contains(.body)) {
                 if (value.fastGet(globalThis, .body)) |body_| {
                     fields.insert(.body);
-                    req.body.value = Body.Value.fromJS(globalThis, body_) orelse {
-                        return null;
-                    };
+                    req.body.value = try Body.Value.fromJS(globalThis, body_);
                 }
 
-                if (globalThis.hasException()) return null;
+                if (globalThis.hasException()) return error.JSError;
             }
 
             if (!fields.contains(.url)) {
@@ -680,17 +668,17 @@ pub const Request = struct {
                 } else if (@intFromEnum(value) == @intFromEnum(values_to_try[values_to_try.len - 1]) and !is_first_argument_a_url and
                     value.implementsToString(globalThis))
                 {
-                    const str = bun.String.tryFromJS(value, globalThis) orelse return null;
+                    const str = bun.String.tryFromJS(value, globalThis) orelse return error.JSError;
                     req.url = str;
                     if (!req.url.isEmpty())
                         fields.insert(.url);
                 }
 
-                if (globalThis.hasException()) return null;
+                if (globalThis.hasException()) return error.JSError;
             }
 
             if (!fields.contains(.signal)) {
-                if (value.getTruthy(globalThis, "signal")) |signal_| {
+                if (try value.getTruthy(globalThis, "signal")) |signal_| {
                     fields.insert(.signal);
                     if (AbortSignal.fromJS(signal_)) |signal| {
                         //Keep it alive
@@ -700,16 +688,16 @@ pub const Request = struct {
                         if (!globalThis.hasException()) {
                             globalThis.throw("Failed to construct 'Request': signal is not of type AbortSignal.", .{});
                         }
-                        return null;
+                        return error.JSError;
                     }
                 }
 
-                if (globalThis.hasException()) return null;
+                if (globalThis.hasException()) return error.JSError;
             }
 
             if (!fields.contains(.method) or !fields.contains(.headers)) {
-                if (globalThis.hasException()) return null;
-                if (Response.Init.init(globalThis, value) catch null) |response_init| {
+                if (globalThis.hasException()) return error.JSError;
+                if (try Response.Init.init(globalThis, value)) |response_init| {
                     if (!explicit_check or (explicit_check and value.fastGet(globalThis, .headers) != null)) {
                         if (response_init.headers) |headers| {
                             if (!fields.contains(.headers)) {
@@ -721,7 +709,7 @@ pub const Request = struct {
                         }
                     }
 
-                    if (globalThis.hasException()) return null;
+                    if (globalThis.hasException()) return error.JSError;
 
                     if (!explicit_check or (explicit_check and value.fastGet(globalThis, .method) != null)) {
                         if (!fields.contains(.method)) {
@@ -729,20 +717,19 @@ pub const Request = struct {
                             fields.insert(.method);
                         }
                     }
-                    if (globalThis.hasException()) return null;
+                    if (globalThis.hasException()) return error.JSError;
                 }
 
-                if (globalThis.hasException()) return null;
+                if (globalThis.hasException()) return error.JSError;
             }
         }
 
         if (globalThis.hasException()) {
-            return null;
+            return error.JSError;
         }
 
         if (req.url.isEmpty()) {
-            globalThis.throw("Failed to construct 'Request': url is required.", .{});
-            return null;
+            return globalThis.throw2("Failed to construct 'Request': url is required.", .{});
         }
 
         const href = JSC.URL.hrefFromString(req.url);
@@ -754,7 +741,7 @@ pub const Request = struct {
                     req.url,
                 }).throw();
             }
-            return null;
+            return error.JSError;
         }
 
         // hrefFromString increments the reference count if they end up being
@@ -779,16 +766,12 @@ pub const Request = struct {
 
         return req;
     }
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) ?*Request {
+
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Request {
         const arguments_ = callframe.arguments(2);
         const arguments = arguments_.ptr[0..arguments_.len];
 
-        const request = constructInto(globalThis, arguments) orelse {
-            return null;
-        };
+        const request = try constructInto(globalThis, arguments);
         return Request.new(request);
     }
 
@@ -802,7 +785,7 @@ pub const Request = struct {
         this: *Request,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const this_value = callframe.this();
         var cloned = this.clone(getAllocator(globalThis), globalThis);
 
diff --git a/src/bun.js/webcore/response.zig b/src/bun.js/webcore/response.zig
index ede288b541e618..86293e57bcdf04 100644
--- a/src/bun.js/webcore/response.zig
+++ b/src/bun.js/webcore/response.zig
@@ -260,7 +260,7 @@ pub const Response = struct {
         this: *Response,
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const this_value = callframe.this();
         const cloned = this.clone(globalThis);
         if (globalThis.hasException()) {
@@ -363,7 +363,7 @@ pub const Response = struct {
     pub fn constructJSON(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const args_list = callframe.arguments(2);
         // https://github.com/remix-run/remix/blob/db2c31f64affb2095e4286b91306b96435967969/packages/remix-server-runtime/responses.ts#L4
         var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), args_list.ptr[0..args_list.len]);
@@ -431,7 +431,7 @@ pub const Response = struct {
     pub fn constructRedirect(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         var args_list = callframe.arguments(4);
         // https://github.com/remix-run/remix/blob/db2c31f64affb2095e4286b91306b96435967969/packages/remix-server-runtime/responses.ts#L4
         var args = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), args_list.ptr[0..args_list.len]);
@@ -453,7 +453,7 @@ pub const Response = struct {
             var url_string = ZigString.init("");
 
             if (@intFromEnum(url_string_value) != 0) {
-                url_string = url_string_value.getZigString(globalThis.ptr());
+                url_string = url_string_value.getZigString(globalThis);
             }
             url_string_slice = url_string.toSlice(getAllocator(globalThis));
             var did_succeed = false;
@@ -493,7 +493,7 @@ pub const Response = struct {
     pub fn constructError(
         globalThis: *JSC.JSGlobalObject,
         _: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const response = bun.new(
             Response,
             Response{
@@ -509,76 +509,42 @@ pub const Response = struct {
         return response.toJS(globalThis);
     }
 
-    pub fn constructor(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) ?*Response {
-        const args_list = brk: {
-            var args = callframe.arguments(2);
-            if (args.len > 1 and args.ptr[1].isEmptyOrUndefinedOrNull()) {
-                args.len = 1;
-            }
-            break :brk args;
-        };
-
-        const arguments = args_list.ptr[0..args_list.len];
-
-        var init: Init = @as(?Init, brk: {
-            switch (arguments.len) {
-                0 => {
-                    break :brk Init{
-                        .status_code = 200,
-                        .headers = null,
-                    };
-                },
-                1 => {
-                    break :brk Init{
-                        .status_code = 200,
-                        .headers = null,
-                    };
-                },
-                else => {
-                    if (arguments[1].isObject()) {
-                        break :brk Init.init(globalThis, arguments[1]) catch null;
-                    }
-
-                    if (!globalThis.hasException()) {
-                        globalThis.throwInvalidArguments("new Response() requires a Response-like object in the 2nd argument", .{});
-                    }
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*Response {
+        const arguments = callframe.argumentsAsArray(2);
 
-                    break :brk null;
-                },
+        var init: Init = (brk: {
+            if (arguments[1].isUndefinedOrNull()) {
+                break :brk Init{
+                    .status_code = 200,
+                    .headers = null,
+                };
+            }
+            if (arguments[1].isObject()) {
+                break :brk try Init.init(globalThis, arguments[1]) orelse unreachable;
             }
-            unreachable;
-        }) orelse return null;
+            if (!globalThis.hasException()) {
+                return globalThis.throwInvalidArguments2("Failed to construct 'Response': The provided body value is not of type 'ResponseInit'", .{});
+            }
+            return error.JSError;
+        });
+        errdefer init.deinit(bun.default_allocator);
 
         if (globalThis.hasException()) {
-            init.deinit(bun.default_allocator);
-            return null;
+            return error.JSError;
         }
 
         var body: Body = brk: {
-            switch (arguments.len) {
-                0 => {
-                    break :brk Body{
-                        .value = Body.Value{ .Null = {} },
-                    };
-                },
-                else => {
-                    break :brk Body.extract(globalThis, arguments[0]);
-                },
+            if (arguments[0].isUndefinedOrNull()) {
+                break :brk Body{
+                    .value = Body.Value{ .Null = {} },
+                };
             }
-            unreachable;
-        } orelse {
-            init.deinit(bun.default_allocator);
-
-            return null;
+            break :brk try Body.extract(globalThis, arguments[0]);
         };
+        errdefer body.deinit(bun.default_allocator);
 
         if (globalThis.hasException()) {
-            body.deinit(bun.default_allocator);
-            init.deinit(bun.default_allocator);
-            return null;
+            return error.JSError;
         }
 
         var response = bun.new(Response, Response{
@@ -616,7 +582,7 @@ pub const Response = struct {
             return that;
         }
 
-        pub fn init(globalThis: *JSGlobalObject, response_init: JSC.JSValue) !?Init {
+        pub fn init(globalThis: *JSGlobalObject, response_init: JSC.JSValue) bun.JSError!?Init {
             var result = Init{ .status_code = 200 };
             errdefer {
                 result.deinit(bun.default_allocator);
@@ -652,7 +618,7 @@ pub const Response = struct {
                         result.headers = orig.cloneThis(globalThis);
                     }
                 } else {
-                    result.headers = FetchHeaders.createFromJS(globalThis.ptr(), headers);
+                    result.headers = FetchHeaders.createFromJS(globalThis, headers);
                 }
             }
 
@@ -798,13 +764,6 @@ pub const Fetch = struct {
         break :brk errors;
     };
 
-    comptime {
-        if (!JSC.is_bindgen) {
-            _ = Bun__fetch;
-            _ = Bun__fetchPreconnect;
-        }
-    }
-
     pub const FetchTasklet = struct {
         const log = Output.scoped(.FetchTasklet, false);
 
@@ -1293,17 +1252,28 @@ pub const Fetch = struct {
                     if (BoringSSL.d2i_X509(null, &cert_ptr, @intCast(cert.len))) |x509| {
                         defer BoringSSL.X509_free(x509);
                         const globalObject = this.global_this;
-                        const js_cert = X509.toJS(x509, globalObject);
+                        const js_cert = X509.toJS(x509, globalObject) catch |err| {
+                            switch (err) {
+                                error.JSError => {},
+                                error.OutOfMemory => globalObject.throwOutOfMemory(),
+                            }
+                            const check_result = globalObject.tryTakeException().?;
+                            // mark to wait until deinit
+                            this.is_waiting_abort = this.result.has_more;
+                            this.abort_reason.set(globalObject, check_result);
+                            this.signal_store.aborted.store(true, .monotonic);
+                            this.tracker.didCancel(this.global_this);
+                            // we need to abort the request
+                            if (this.http) |http_| http.http_thread.scheduleShutdown(http_);
+                            this.result.fail = error.ERR_TLS_CERT_ALTNAME_INVALID;
+                            return false;
+                        };
                         var hostname: bun.String = bun.String.createUTF8(certificate_info.hostname);
                         defer hostname.deref();
                         const js_hostname = hostname.toJS(globalObject);
                         js_hostname.ensureStillAlive();
                         js_cert.ensureStillAlive();
-                        const check_result = check_server_identity.call(
-                            globalObject,
-                            .undefined,
-                            &.{ js_hostname, js_cert },
-                        ) catch |err| globalObject.takeException(err);
+                        const check_result = check_server_identity.call(globalObject, .undefined, &.{ js_hostname, js_cert }) catch |err| globalObject.takeException(err);
 
                         // > Returns <Error> object [...] on failure
                         if (check_result.isAnyError()) {
@@ -1926,18 +1896,21 @@ pub const Fetch = struct {
         return JSPromise.resolvedPromiseValue(globalThis, response.toJS(globalThis));
     }
 
-    pub export fn Bun__fetchPreconnect(
+    comptime {
+        const Bun__fetchPreconnect = JSC.toJSHostFunction(Bun__fetchPreconnect_);
+        @export(Bun__fetchPreconnect, .{ .name = "Bun__fetchPreconnect" });
+    }
+    pub fn Bun__fetchPreconnect_(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments = callframe.arguments(1).slice();
 
         if (arguments.len < 1) {
-            globalObject.throwNotEnoughArguments("fetch.preconnect", 1, arguments.len);
-            return .zero;
+            return globalObject.throwNotEnoughArguments("fetch.preconnect", 1, arguments.len);
         }
 
-        var url_str = JSC.URL.hrefFromJS(arguments[0], globalObject);
+        var url_str = try JSC.URL.hrefFromJS(arguments[0], globalObject);
         defer url_str.deref();
 
         if (globalObject.hasException()) {
@@ -1978,41 +1951,37 @@ pub const Fetch = struct {
     }
 
     const StringOrURL = struct {
-        pub fn fromJS(value: JSC.JSValue, globalThis: *JSC.JSGlobalObject) ?bun.String {
+        pub fn fromJS(value: JSC.JSValue, globalThis: *JSC.JSGlobalObject) bun.JSError!?bun.String {
             if (value.isString()) {
-                return bun.String.tryFromJS(value, globalThis);
+                return try bun.String.fromJS2(value, globalThis);
             }
 
-            const out = JSC.URL.hrefFromJS(value, globalThis);
-            if (out.tag == .Dead) {
-                return null;
-            }
+            const out = try JSC.URL.hrefFromJS(value, globalThis);
+            if (out.tag == .Dead) return null;
             return out;
         }
     };
 
-    pub export fn Bun__fetch(
+    comptime {
+        const Bun__fetch = JSC.toJSHostFunction(Bun__fetch_);
+        @export(Bun__fetch, .{ .name = "Bun__fetch" });
+    }
+    pub fn Bun__fetch_(
         ctx: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
-        const globalThis = ctx.ptr();
+        const globalThis = ctx;
         const arguments = callframe.arguments(2);
         bun.Analytics.Features.fetch += 1;
         const vm = JSC.VirtualMachine.get();
 
-        var exception_val = [_]JSC.C.JSValueRef{null};
-        const exception: JSC.C.ExceptionRef = &exception_val;
         var memory_reporter = bun.default_allocator.create(JSC.MemoryReportingAllocator) catch bun.outOfMemory();
         // used to clean up dynamically allocated memory on error (a poor man's errdefer)
         var is_error = false;
         var allocator = memory_reporter.wrap(bun.default_allocator);
+        errdefer bun.default_allocator.destroy(memory_reporter);
         defer {
-            if (exception.* != null) {
-                is_error = true;
-                ctx.throwValue(JSC.JSValue.c(exception.*));
-            }
-
             memory_reporter.report(globalThis.vm());
 
             if (is_error) bun.default_allocator.destroy(memory_reporter);
@@ -2075,10 +2044,6 @@ pub const Fetch = struct {
                 sig.unref();
             }
 
-            if (!is_error and globalThis.hasException()) {
-                is_error = true;
-            }
-
             unix_socket_path.deinit();
 
             allocator.free(url_proxy_buffer);
@@ -2124,7 +2089,7 @@ pub const Fetch = struct {
             break :brk null;
         };
         // If it's NOT a Request or a subclass of Request, treat the first argument as a URL.
-        const url_str_optional = if (first_arg.as(Request) == null) StringOrURL.fromJS(first_arg, globalThis) else null;
+        const url_str_optional = if (first_arg.as(Request) == null) try StringOrURL.fromJS(first_arg, globalThis) else null;
         if (globalThis.hasException()) {
             is_error = true;
             return .zero;
@@ -2148,9 +2113,7 @@ pub const Fetch = struct {
             if (request_init_object) |request_init| {
                 if (request_init.fastGet(globalThis, .url)) |url_| {
                     if (!url_.isUndefined()) {
-                        if (bun.String.tryFromJS(url_, globalThis)) |str| {
-                            break :extract_url str;
-                        }
+                        break :extract_url try bun.String.fromJS2(url_, globalThis);
                     }
                 }
             }
@@ -2217,7 +2180,7 @@ pub const Fetch = struct {
         // "method"
         method = extract_method: {
             if (options_object) |options| {
-                if (options.getTruthyComptime(globalThis, "method")) |method_| {
+                if (try options.getTruthyComptime(globalThis, "method")) |method_| {
                     break :extract_method Method.fromJS(globalThis, method_);
                 }
 
@@ -2232,7 +2195,7 @@ pub const Fetch = struct {
             }
 
             if (request_init_object) |req| {
-                if (req.getTruthyComptime(globalThis, "method")) |method_| {
+                if (try req.getTruthyComptime(globalThis, "method")) |method_| {
                     break :extract_method Method.fromJS(globalThis, method_);
                 }
 
@@ -2317,21 +2280,14 @@ pub const Fetch = struct {
                                 return .zero;
                             }
 
-                            if (SSLConfig.inJS(vm, globalThis, tls, exception)) |config| {
-                                if (exception.* != null) {
-                                    is_error = true;
-                                    return .zero;
-                                }
-
+                            if (SSLConfig.fromJS(vm, globalThis, tls) catch {
+                                is_error = true;
+                                return .zero;
+                            }) |config| {
                                 const ssl_config_object = bun.default_allocator.create(SSLConfig) catch bun.outOfMemory();
                                 ssl_config_object.* = config;
                                 break :extract_ssl_config ssl_config_object;
                             }
-
-                            if (exception.* != null) {
-                                is_error = true;
-                                return .zero;
-                            }
                         }
                     }
                 }
@@ -2504,7 +2460,7 @@ pub const Fetch = struct {
                 if (objects_to_try[i] != .zero) {
                     if (objects_to_try[i].get(globalThis, "proxy")) |proxy_arg| {
                         if (proxy_arg.isString() and proxy_arg.getLength(ctx) > 0) {
-                            var href = JSC.URL.hrefFromJS(proxy_arg, globalThis);
+                            var href = try JSC.URL.hrefFromJS(proxy_arg, globalThis);
                             if (href.tag == .Dead) {
                                 const err = JSC.toTypeError(.ERR_INVALID_ARG_VALUE, "fetch() proxy URL is invalid", .{}, ctx);
                                 is_error = true;
@@ -2596,10 +2552,8 @@ pub const Fetch = struct {
             if (options_object) |options| {
                 if (options.fastGet(globalThis, .body)) |body__| {
                     if (!body__.isUndefined()) {
-                        if (Body.Value.fromJS(ctx.ptr(), body__)) |body_const| {
-                            var body_value = body_const;
-                            break :extract_body body_value.useAsAnyBlob();
-                        }
+                        var body_value = try Body.Value.fromJS(ctx, body__);
+                        break :extract_body body_value.useAsAnyBlob();
                     }
                 }
 
@@ -2622,10 +2576,8 @@ pub const Fetch = struct {
             if (request_init_object) |req| {
                 if (req.fastGet(globalThis, .body)) |body__| {
                     if (!body__.isUndefined()) {
-                        if (Body.Value.fromJS(ctx.ptr(), body__)) |body_const| {
-                            var body_value = body_const;
-                            break :extract_body body_value.useAsAnyBlob();
-                        }
+                        var body_value = try Body.Value.fromJS(ctx, body__);
+                        break :extract_body body_value.useAsAnyBlob();
                     }
                 }
             }
@@ -2659,7 +2611,7 @@ pub const Fetch = struct {
                                 break :brk headers__;
                             }
 
-                            if (FetchHeaders.createFromJS(ctx.ptr(), headers_value)) |headers__| {
+                            if (FetchHeaders.createFromJS(ctx, headers_value)) |headers__| {
                                 fetch_headers_to_deref = headers__;
                                 break :brk headers__;
                             }
@@ -2693,7 +2645,7 @@ pub const Fetch = struct {
                                 break :brk headers__;
                             }
 
-                            if (FetchHeaders.createFromJS(ctx.ptr(), headers_value)) |headers__| {
+                            if (FetchHeaders.createFromJS(ctx, headers_value)) |headers__| {
                                 fetch_headers_to_deref = headers__;
                                 break :brk headers__;
                             }
diff --git a/src/bun.js/webcore/streams.zig b/src/bun.js/webcore/streams.zig
index abd5fa534802f7..8a0a67899956c5 100644
--- a/src/bun.js/webcore/streams.zig
+++ b/src/bun.js/webcore/streams.zig
@@ -526,7 +526,7 @@ pub const StreamStart = union(Tag) {
         }
     }
 
-    pub fn fromJS(globalThis: *JSGlobalObject, value: JSValue) StreamStart {
+    pub fn fromJS(globalThis: *JSGlobalObject, value: JSValue) bun.JSError!StreamStart {
         if (value.isEmptyOrUndefinedOrNull() or !value.isObject()) {
             return .{ .empty = {} };
         }
@@ -543,7 +543,7 @@ pub const StreamStart = union(Tag) {
         globalThis: *JSGlobalObject,
         value: JSValue,
         comptime tag: Tag,
-    ) StreamStart {
+    ) bun.JSError!StreamStart {
         if (value.isEmptyOrUndefinedOrNull() or !value.isObject()) {
             return .{ .empty = {} };
         }
@@ -612,7 +612,7 @@ pub const StreamStart = union(Tag) {
                             },
                         },
                     };
-                } else if (value.getTruthy(globalThis, "fd")) |fd_value| {
+                } else if (try value.getTruthy(globalThis, "fd")) |fd_value| {
                     if (!fd_value.isAnyInt()) {
                         return .{
                             .err = Syscall.Error{
@@ -1673,7 +1673,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             return shim.cppFn("setDestroyCallback", .{ value, callback });
         }
 
-        pub fn construct(globalThis: *JSGlobalObject, _: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn construct(globalThis: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
 
             if (comptime !@hasDecl(SinkType, "construct")) {
@@ -1745,7 +1745,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
         }
 
-        pub fn write(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn write(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
             var this = getThis(globalThis, callframe) orelse return invalidThis(globalThis);
 
@@ -1814,7 +1814,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             return this.sink.writeLatin1(.{ .temporary = bun.ByteList.initConst(str.slice()) }).toJS(globalThis);
         }
 
-        pub fn writeUTF8(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn writeUTF8(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
 
             var this = getThis(globalThis, callframe) orelse return invalidThis(globalThis);
@@ -1867,7 +1867,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             return this.sink.end(null).toJS(globalThis);
         }
 
-        pub fn flush(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn flush(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
 
             var this = getThis(globalThis, callframe) orelse return invalidThis(globalThis);
@@ -1902,7 +1902,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             return this.sink.flush().toJS(globalThis);
         }
 
-        pub fn start(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn start(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
 
             var this = getThis(globalThis, callframe) orelse return invalidThis(globalThis);
@@ -1917,11 +1917,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
             if (comptime @hasField(StreamStart, name_)) {
                 return this.sink.start(
                     if (callframe.argumentsCount() > 0)
-                        StreamStart.fromJSWithTag(
-                            globalThis,
-                            callframe.argument(0),
-                            comptime @field(StreamStart, name_),
-                        )
+                        try StreamStart.fromJSWithTag(globalThis, callframe.argument(0), comptime @field(StreamStart, name_))
                     else
                         StreamStart{ .empty = {} },
                 ).toJS(globalThis);
@@ -1929,13 +1925,13 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
             return this.sink.start(
                 if (callframe.argumentsCount() > 0)
-                    StreamStart.fromJS(globalThis, callframe.argument(0))
+                    try StreamStart.fromJS(globalThis, callframe.argument(0))
                 else
                     StreamStart{ .empty = {} },
             ).toJS(globalThis);
         }
 
-        pub fn end(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+        pub fn end(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             JSC.markBinding(@src());
 
             var this = getThis(globalThis, callframe) orelse return invalidThis(globalThis);
@@ -1984,14 +1980,20 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
                 this.sink.updateRef(value);
         }
 
+        const jsWrite = JSC.toJSHostFunction(write);
+        const jsFlush = JSC.toJSHostFunction(flush);
+        const jsStart = JSC.toJSHostFunction(start);
+        const jsEnd = JSC.toJSHostFunction(end);
+        const jsConstruct = JSC.toJSHostFunction(construct);
+
         comptime {
             @export(finalize, .{ .name = shim.symbolName("finalize") });
-            @export(write, .{ .name = shim.symbolName("write") });
+            @export(jsWrite, .{ .name = shim.symbolName("write") });
             @export(close, .{ .name = shim.symbolName("close") });
-            @export(flush, .{ .name = shim.symbolName("flush") });
-            @export(start, .{ .name = shim.symbolName("start") });
-            @export(end, .{ .name = shim.symbolName("end") });
-            @export(construct, .{ .name = shim.symbolName("construct") });
+            @export(jsFlush, .{ .name = shim.symbolName("flush") });
+            @export(jsStart, .{ .name = shim.symbolName("start") });
+            @export(jsEnd, .{ .name = shim.symbolName("end") });
+            @export(jsConstruct, .{ .name = shim.symbolName("construct") });
             @export(endWithSink, .{ .name = shim.symbolName("endWithSink") });
             @export(updateRef, .{ .name = shim.symbolName("updateRef") });
 
@@ -2015,7 +2017,7 @@ pub fn NewJSSink(comptime SinkType: type, comptime name_: []const u8) type {
 
 //         socket: Socket,
 
-//         pub fn connect(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+//         pub fn connect(globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
 //             JSC.markBinding(@src());
 
 //             var this = @ptrCast(*ThisSocket, @alignCast( fromJS(globalThis, callframe.this()) orelse {
@@ -2783,7 +2785,7 @@ pub fn ReadableStreamSource(
             return ReadableStream.fromNative(globalThis, out_value);
         }
 
-        pub fn setRawModeFromJS(this: *ReadableStreamSourceType, global: *JSC.JSGlobalObject, call_frame: *JSC.CallFrame) JSValue {
+        pub fn setRawModeFromJS(this: *ReadableStreamSourceType, global: *JSC.JSGlobalObject, call_frame: *JSC.CallFrame) bun.JSError!JSValue {
             if (@hasDecl(Context, "setRawMode")) {
                 const flag = call_frame.argument(0);
                 if (Environment.allow_assert) {
@@ -2825,7 +2827,7 @@ pub fn ReadableStreamSource(
                 return null;
             }
 
-            pub fn pull(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn pull(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 const this_jsvalue = callFrame.this();
                 const arguments = callFrame.arguments(2);
@@ -2841,7 +2843,7 @@ pub fn ReadableStreamSource(
                 );
             }
 
-            pub fn start(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn start(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.globalThis = globalThis;
                 this.this_jsvalue = callFrame.this();
@@ -2890,7 +2892,7 @@ pub fn ReadableStreamSource(
                 }
             }
 
-            pub fn cancel(this: *ReadableStreamSourceType, globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn cancel(this: *ReadableStreamSourceType, globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 _ = globalObject; // autofix
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
@@ -2955,7 +2957,7 @@ pub fn ReadableStreamSource(
                 return .undefined;
             }
 
-            pub fn updateRef(this: *ReadableStreamSourceType, globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn updateRef(this: *ReadableStreamSourceType, globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 _ = globalObject; // autofix
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
@@ -2981,7 +2983,7 @@ pub fn ReadableStreamSource(
                 _ = this.decrementCount();
             }
 
-            pub fn drain(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn drain(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
                 var list = this.drain();
@@ -2991,7 +2993,7 @@ pub fn ReadableStreamSource(
                 return JSValue.jsUndefined();
             }
 
-            pub fn text(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn text(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
 
@@ -3003,7 +3005,7 @@ pub fn ReadableStreamSource(
                 return .zero;
             }
 
-            pub fn arrayBuffer(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn arrayBuffer(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
 
@@ -3015,7 +3017,7 @@ pub fn ReadableStreamSource(
                 return .zero;
             }
 
-            pub fn blob(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn blob(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
 
@@ -3027,7 +3029,7 @@ pub fn ReadableStreamSource(
                 return .zero;
             }
 
-            pub fn bytes(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn bytes(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
 
@@ -3039,7 +3041,7 @@ pub fn ReadableStreamSource(
                 return .zero;
             }
 
-            pub fn json(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) JSC.JSValue {
+            pub fn json(this: *ReadableStreamSourceType, globalThis: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
                 JSC.markBinding(@src());
                 this.this_jsvalue = callFrame.this();
 
diff --git a/src/bun.zig b/src/bun.zig
index 81803574a83442..a2a39d1df9873c 100644
--- a/src/bun.zig
+++ b/src/bun.zig
@@ -37,18 +37,8 @@ else
 pub const callmod_inline: std.builtin.CallModifier = if (builtin.mode == .Debug) .auto else .always_inline;
 pub const callconv_inline: std.builtin.CallingConvention = if (builtin.mode == .Debug) .Unspecified else .Inline;
 
-const cmath = struct {
-    extern "c" fn powf(x: f32, y: f32) f32;
-    extern "c" fn pow(x: f64, y: f64) f64;
-};
-
-pub inline fn powf(x: f32, y: f32) f32 {
-    return cmath.powf(x, y);
-}
-
-pub inline fn pow(x: f64, y: f64) f64 {
-    return cmath.pow(x, y);
-}
+pub extern "c" fn powf(x: f32, y: f32) f32;
+pub extern "c" fn pow(x: f64, y: f64) f64;
 
 /// Restrict a value to a certain interval unless it is a float and NaN.
 pub inline fn clamp(self: anytype, min: @TypeOf(self), max: @TypeOf(self)) @TypeOf(self) {
@@ -98,17 +88,18 @@ pub inline fn namedAllocator(comptime name: [:0]const u8) std.mem.Allocator {
     return default_allocator;
 }
 
-pub const OOM = error{OutOfMemory};
+pub const OOM = std.mem.Allocator.Error;
 
 pub const JSError = error{
-    /// There is an active exception on the global object. Options:
-    ///
-    /// - Bubble it up to the caller
-    /// - Call `global.takeException(err)` to get the JSValue of the exception,
-    /// - Call `global.reportActiveExceptionAsUnhandled(err)` to make it unhandled.
+    /// There is an active exception on the global object.
+    /// You should almost never have to construct this manually.
     JSError,
+    // XXX: This is temporary! meghan will remove this soon
+    OutOfMemory,
 };
 
+pub const JSOOM = OOM || JSError;
+
 pub const detectCI = @import("./ci_info.zig").detectCI;
 
 pub const C = @import("root").C;
@@ -139,6 +130,7 @@ pub const patch = @import("./patch.zig");
 pub const ini = @import("./ini.zig");
 pub const Bitflags = @import("./bitflags.zig").Bitflags;
 pub const css = @import("./css/css_parser.zig");
+pub const validators = @import("./bun.js/node/util/validators.zig");
 
 pub const shell = struct {
     pub usingnamespace @import("./shell/shell.zig");
@@ -327,7 +319,7 @@ pub const strings = @import("string_immutable.zig");
 pub const MutableString = @import("string_mutable.zig").MutableString;
 pub const RefCount = @import("./ref_count.zig").RefCount;
 
-pub const MAX_PATH_BYTES: usize = if (Environment.isWasm) 1024 else std.fs.MAX_PATH_BYTES;
+pub const MAX_PATH_BYTES: usize = if (Environment.isWasm) 1024 else std.fs.max_path_bytes;
 pub const PathBuffer = [MAX_PATH_BYTES]u8;
 pub const WPathBuffer = [std.os.windows.PATH_MAX_WIDE]u16;
 pub const OSPathChar = if (Environment.isWindows) u16 else u8;
@@ -909,6 +901,18 @@ pub fn getRuntimeFeatureFlag(comptime flag: [:0]const u8) bool {
     }.get();
 }
 
+pub fn getenvZAnyCase(key: [:0]const u8) ?[]const u8 {
+    for (std.os.environ) |lineZ| {
+        const line = sliceTo(lineZ, 0);
+        const key_end = strings.indexOfCharUsize(line, '=') orelse line.len;
+        if (strings.eqlCaseInsensitiveASCII(line[0..key_end], key, true)) {
+            return line[@min(key_end + 1, line.len)..];
+        }
+    }
+
+    return null;
+}
+
 /// This wrapper exists to avoid the call to sliceTo(0)
 /// Zig's sliceTo(0) is scalar
 pub fn getenvZ(key: [:0]const u8) ?[]const u8 {
@@ -917,16 +921,7 @@ pub fn getenvZ(key: [:0]const u8) ?[]const u8 {
     }
 
     if (comptime Environment.isWindows) {
-        // Windows UCRT will fill this in for us
-        for (std.os.environ) |lineZ| {
-            const line = sliceTo(lineZ, 0);
-            const key_end = strings.indexOfCharUsize(line, '=') orelse line.len;
-            if (strings.eqlCaseInsensitiveASCII(line[0..key_end], key, true)) {
-                return line[@min(key_end + 1, line.len)..];
-            }
-        }
-
-        return null;
+        return getenvZAnyCase(key);
     }
 
     const ptr = std.c.getenv(key.ptr) orelse return null;
@@ -1700,7 +1695,7 @@ pub noinline fn maybeHandlePanicDuringProcessReload() void {
     }
 
     // This shouldn't be reachable, but it can technically be because
-    // pthread_exit is a request and not guranteed.
+    // pthread_exit is a request and not guaranteed.
     if (isProcessReloadInProgressOnAnotherThread()) {
         while (true) {
             std.atomic.spinLoopHint();
@@ -2078,8 +2073,6 @@ pub const WTF = struct {
     pub const StringImpl = @import("./string.zig").WTFStringImpl;
 };
 
-pub const ArenaAllocator = @import("./ArenaAllocator.zig").ArenaAllocator;
-
 pub const Wyhash11 = @import("./wyhash.zig").Wyhash11;
 
 pub const RegularExpression = @import("./bun.js/bindings/RegularExpression.zig").RegularExpression;
@@ -3315,6 +3308,7 @@ pub inline fn resolveSourcePath(
     comptime sub_path: string,
 ) string {
     return comptime path: {
+        @setEvalBranchQuota(2000000);
         var buf: bun.PathBuffer = undefined;
         var fba = std.heap.FixedBufferAllocator.init(&buf);
         const resolved = (std.fs.path.resolve(fba.allocator(), &.{
@@ -3339,7 +3333,7 @@ const RuntimeEmbedRoot = enum {
 pub fn runtimeEmbedFile(
     comptime root: RuntimeEmbedRoot,
     comptime sub_path: []const u8,
-) []const u8 {
+) [:0]const u8 {
     comptime assert(Environment.isDebug);
     comptime assert(!Environment.codegen_embed);
 
@@ -3349,11 +3343,18 @@ pub fn runtimeEmbedFile(
     };
 
     const static = struct {
-        var storage: []const u8 = undefined;
+        var storage: [:0]const u8 = undefined;
         var once = std.once(load);
 
         fn load() void {
-            storage = std.fs.cwd().readFileAlloc(default_allocator, abs_path, std.math.maxInt(usize)) catch |e| {
+            storage = std.fs.cwd().readFileAllocOptions(
+                default_allocator,
+                abs_path,
+                std.math.maxInt(usize),
+                null,
+                @alignOf(u8),
+                '\x00',
+            ) catch |e| {
                 Output.panic(
                     \\Failed to load '{s}': {}
                     \\
@@ -3458,6 +3459,9 @@ pub fn SliceIterator(comptime T: type) type {
 
 pub const Futex = @import("./futex.zig");
 
+// TODO: migrate
+pub const ArenaAllocator = std.heap.ArenaAllocator;
+
 pub const crash_handler = @import("crash_handler.zig");
 pub const handleErrorReturnTrace = crash_handler.handleErrorReturnTrace;
 
@@ -3954,7 +3958,7 @@ pub fn GenericIndex(backing_int: type, uid: anytype) type {
             none = std.math.maxInt(backing_int),
             _,
 
-            pub inline fn init(maybe: ?Index) ?Index {
+            pub inline fn init(maybe: ?Index) Optional {
                 return if (maybe) |i| i.toOptional() else .none;
             }
 
@@ -4087,3 +4091,14 @@ pub inline fn writeAnyToHasher(hasher: anytype, thing: anytype) void {
     comptime assertNoPointers(@TypeOf(thing)); // catch silly mistakes
     hasher.update(std.mem.asBytes(&thing));
 }
+
+pub inline fn isComptimeKnown(x: anytype) bool {
+    return comptime @typeInfo(@TypeOf(.{x})).Struct.fields[0].is_comptime;
+}
+
+pub inline fn itemOrNull(comptime T: type, slice: []const T, index: usize) ?T {
+    return if (index < slice.len) slice[index] else null;
+}
+
+/// Code used by the classes generator
+pub const gen_classes_lib = @import("gen_classes_lib.zig");
diff --git a/src/bun_js.zig b/src/bun_js.zig
index fb97c269cb6a2c..565bf3e8d516ea 100644
--- a/src/bun_js.zig
+++ b/src/bun_js.zig
@@ -339,23 +339,19 @@ pub const Run = struct {
                 Output.prettyErrorln("Error occurred loading entry point: {s}", .{@errorName(err)});
                 Output.flush();
             }
-
-            if (vm.hot_reload != .none) {
-                vm.eventLoop().tick();
-                vm.eventLoop().tickPossiblyForever();
-            } else {
-                vm.exit_handler.exit_code = 1;
-                vm.onExit();
-                if (run.any_unhandled) {
-                    bun.JSC.SavedSourceMap.MissingSourceMapNoteInfo.print();
-
-                    Output.prettyErrorln(
-                        "<r>\n<d>{s}<r>",
-                        .{Global.unhandled_error_bun_version_string},
-                    );
-                }
-                vm.globalExit();
+            // TODO: Do a event loop tick when we figure out how to watch the file that wasn't found
+            //   under hot reload mode
+            vm.exit_handler.exit_code = 1;
+            vm.onExit();
+            if (run.any_unhandled) {
+                bun.JSC.SavedSourceMap.MissingSourceMapNoteInfo.print();
+
+                Output.prettyErrorln(
+                    "<r>\n<d>{s}<r>",
+                    .{Global.unhandled_error_bun_version_string},
+                );
             }
+            vm.globalExit();
         }
 
         // don't run the GC if we don't actually need to
@@ -415,7 +411,7 @@ pub const Run = struct {
                         if (result.asAnyPromise()) |promise| {
                             switch (promise.status(vm.jsc)) {
                                 .pending => {
-                                    result._then(vm.global, .undefined, Bun__onResolveEntryPointResult, Bun__onRejectEntryPointResult);
+                                    result._then2(vm.global, .undefined, Bun__onResolveEntryPointResult, Bun__onRejectEntryPointResult);
 
                                     vm.tick();
                                     vm.eventLoop().autoTickActive();
diff --git a/src/bundler.zig b/src/bundler.zig
index 3db3a446e03b64..36b674724cb43a 100644
--- a/src/bundler.zig
+++ b/src/bundler.zig
@@ -1594,7 +1594,7 @@ pub const Bundler = struct {
             },
             // TODO: use lazy export AST
             .text => {
-                const expr = js_ast.Expr.init(js_ast.E.UTF8String, js_ast.E.UTF8String{
+                const expr = js_ast.Expr.init(js_ast.E.String, js_ast.E.String{
                     .data = source.contents,
                 }, logger.Loc.Empty);
                 const stmt = js_ast.Stmt.alloc(js_ast.S.ExportDefault, js_ast.S.ExportDefault{
diff --git a/src/bundler/bundle_v2.zig b/src/bundler/bundle_v2.zig
index 9e5dfb43787384..7eb259478f3555 100644
--- a/src/bundler/bundle_v2.zig
+++ b/src/bundler/bundle_v2.zig
@@ -324,10 +324,8 @@ const Watcher = bun.JSC.NewHotReloader(BundleV2, EventLoop, true);
 pub const BakeEntryPoint = struct {
     path: []const u8,
     graph: bake.Graph,
-
     css: bool = false,
     client_wrapped: bool = false,
-    route_index: bake.DevServer.Route.Index.Optional = .none,
 
     pub fn init(path: []const u8, graph: bake.Graph) BakeEntryPoint {
         return .{ .path = path, .graph = graph };
@@ -337,7 +335,7 @@ pub const BakeEntryPoint = struct {
         return .{ .path = path, .graph = graph, .client_wrapped = true };
     }
 
-    pub fn route(path: []const u8, index: bake.DevServer.Route.Index) BakeEntryPoint {
+    pub fn route(path: []const u8, index: bake.DevServer.RouteBundle.Index) BakeEntryPoint {
         return .{
             .path = path,
             .graph = .server,
@@ -349,7 +347,23 @@ pub const BakeEntryPoint = struct {
         return .{ .path = path, .graph = .client, .css = true };
     }
 };
-
+fn genericPathWithPrettyInitialized(path: Fs.Path, target: options.Target, top_level_dir: string, allocator: std.mem.Allocator) !Fs.Path {
+    // TODO: outbase
+    var buf: bun.PathBuffer = undefined;
+    const rel = bun.path.relativePlatform(top_level_dir, path.text, .loose, false);
+    var path_clone = path;
+
+    // stack-allocated temporary is not leaked because dupeAlloc on the path will
+    // move .pretty into the heap. that function also fixes some slash issues.
+    if (target == .bake_server_components_ssr) {
+        // the SSR graph needs different pretty names or else HMR mode will
+        // confuse the two modules.
+        path_clone.pretty = std.fmt.bufPrint(&buf, "ssr:{s}", .{rel}) catch buf[0..];
+    } else {
+        path_clone.pretty = rel;
+    }
+    return path_clone.dupeAllocFixPretty(allocator);
+}
 pub const BundleV2 = struct {
     bundler: *Bundler,
     /// When Server Component is enabled, this is used for the client bundles
@@ -1009,10 +1023,6 @@ pub const BundleV2 = struct {
 
                         try this.graph.entry_points.append(this.graph.allocator, Index.source(source_index));
 
-                        if (entry_point.route_index.unwrap()) |route_index| {
-                            _ = try this.bundler.options.dev_server.?.server_graph.insertStaleExtra(resolved.path_pair.primary.text, false, true, route_index);
-                        }
-
                         if (entry_point.css) {
                             try data.css_data.putNoClobber(this.graph.allocator, Index.init(source_index), .{ .imported_on_server = false });
                         }
@@ -1068,16 +1078,14 @@ pub const BundleV2 = struct {
     }
 
     /// This generates the two asts for 'bun:bake/client' and 'bun:bake/server'. Both are generated
-    /// at the same time in one pass over the SBC list.
-    ///
-    ///
+    /// at the same time in one pass over the SCB list.
     pub fn processServerComponentManifestFiles(this: *BundleV2) OOM!void {
         // If a server components is not configured, do nothing
         const fw = this.framework orelse return;
         const sc = fw.server_components orelse return;
 
-        if (this.graph.kit_referenced_client_data) bun.todoPanic(@src(), "implement generation for 'bun:bake/client'", .{});
-        if (!this.graph.kit_referenced_server_data) return;
+        if (!this.graph.kit_referenced_server_data and
+            !this.graph.kit_referenced_client_data) return;
 
         const alloc = this.graph.allocator;
 
@@ -1146,7 +1154,7 @@ pub const BundleV2 = struct {
                         .key = server.newExpr(E.String{ .data = server_key_string }),
                         .value = server.newExpr(E.Object{
                             .properties = try G.Property.List.fromSlice(alloc, &.{
-                                .{ .key = id_string, .value = ssr_path },
+                                .{ .key = id_string, .value = client_path },
                                 .{ .key = name_string, .value = export_name },
                                 .{ .key = chunks_string, .value = empty_array },
                             }),
@@ -1157,14 +1165,14 @@ pub const BundleV2 = struct {
                         .value = server.newExpr(E.Object{
                             .properties = try G.Property.List.fromSlice(alloc, &.{
                                 .{ .key = name_string, .value = export_name },
-                                .{ .key = specifier_string, .value = client_path },
+                                .{ .key = specifier_string, .value = ssr_path },
                             }),
                         }),
                     };
                 }
 
                 try client_manifest_props.append(alloc, .{
-                    .key = ssr_path,
+                    .key = client_path,
                     .value = server.newExpr(E.Object{
                         .properties = G.Property.List.init(client_manifest_items),
                     }),
@@ -1259,8 +1267,8 @@ pub const BundleV2 = struct {
             .source = source,
             .loader = loader,
             .side_effects = switch (loader) {
-                .text, .json, .toml, .file => _resolver.SideEffects.no_side_effects__pure_data,
-                else => _resolver.SideEffects.has_side_effects,
+                .text, .json, .toml, .file => .no_side_effects__pure_data,
+                else => .has_side_effects,
             },
         }) catch bun.outOfMemory();
         var task = this.graph.allocator.create(ParseTask) catch bun.outOfMemory();
@@ -1604,7 +1612,6 @@ pub const BundleV2 = struct {
             bundler.options.entry_points = config.entry_points.keys();
             bundler.options.jsx = config.jsx;
             bundler.options.no_macros = config.no_macros;
-            bundler.options.server_components = config.server_components.client.items.len > 0 or config.server_components.server.items.len > 0;
             bundler.options.loaders = try options.loadersFromTransformOptions(allocator, config.loaders, config.target);
             bundler.options.entry_naming = config.names.entry_point.data;
             bundler.options.chunk_naming = config.names.chunk.data;
@@ -1809,11 +1816,19 @@ pub const BundleV2 = struct {
                 _ = @atomicRmw(usize, &this.graph.parse_pending, .Sub, 1, .monotonic);
             },
             .success => |code| {
+                const should_copy_for_bundling = load.parse_task.defer_copy_for_bundling and code.loader.shouldCopyForBundling(this.bundler.options.experimental_css);
+                if (should_copy_for_bundling) {
+                    const source_index = load.source_index;
+                    var additional_files: *BabyList(AdditionalFile) = &this.graph.input_files.items(.additional_files)[source_index.get()];
+                    additional_files.push(this.graph.allocator, .{ .source_index = source_index.get() }) catch unreachable;
+                    this.graph.input_files.items(.side_effects)[source_index.get()] = _resolver.SideEffects.no_side_effects__pure_data;
+                    this.graph.estimated_file_loader_count += 1;
+                }
                 this.graph.input_files.items(.loader)[load.source_index.get()] = code.loader;
                 this.graph.input_files.items(.source)[load.source_index.get()].contents = code.source_code;
                 var parse_task = load.parse_task;
                 parse_task.loader = code.loader;
-                this.free_list.append(code.source_code) catch unreachable;
+                if (!should_copy_for_bundling) this.free_list.append(code.source_code) catch unreachable;
                 parse_task.contents_or_fd = .{
                     .contents = code.source_code,
                 };
@@ -2252,6 +2267,9 @@ pub const BundleV2 = struct {
     pub fn enqueueOnLoadPluginIfNeeded(this: *BundleV2, parse: *ParseTask) bool {
         if (this.plugins) |plugins| {
             if (plugins.hasAnyMatches(&parse.path, true)) {
+                if (parse.is_entry_point and parse.loader != null and parse.loader.?.shouldCopyForBundling(this.bundler.options.experimental_css)) {
+                    parse.defer_copy_for_bundling = true;
+                }
                 // This is where onLoad plugins are enqueued
                 debug("enqueue onLoad: {s}:{s}", .{
                     parse.path.namespace,
@@ -2274,25 +2292,7 @@ pub const BundleV2 = struct {
     }
 
     fn pathWithPrettyInitialized(this: *BundleV2, path: Fs.Path, target: options.Target) !Fs.Path {
-        if (path.pretty.ptr != path.text.ptr) {
-            // TODO(@paperdave): there is a high chance this dupe is no longer required
-            return path.dupeAlloc(this.graph.allocator);
-        }
-
-        // TODO: outbase
-        var buf: bun.PathBuffer = undefined;
-        const rel = bun.path.relativePlatform(this.bundler.fs.top_level_dir, path.text, .loose, false);
-        var path_clone = path;
-        // stack-allocated temporary is not leaked because dupeAlloc on the path will
-        // move .pretty into the heap. that function also fixes some slash issues.
-        if (target == .bake_server_components_ssr) {
-            // the SSR graph needs different pretty names or else HMR mode will
-            // confuse the two modules.
-            path_clone.pretty = std.fmt.bufPrint(&buf, "ssr:{s}", .{rel}) catch buf[0..];
-        } else {
-            path_clone.pretty = rel;
-        }
-        return path_clone.dupeAllocFixPretty(this.graph.allocator);
+        return genericPathWithPrettyInitialized(path, target, this.bundler.fs.top_level_dir, this.graph.allocator);
     }
 
     fn reserveSourceIndexesForBake(this: *BundleV2) !void {
@@ -3212,6 +3212,10 @@ pub const ParseTask = struct {
     ctx: *BundleV2,
     package_version: string = "",
     is_entry_point: bool = false,
+    /// This is set when the file is an entrypoint, and it has an onLoad plugin.
+    /// In this case we want to defer adding this to additional_files until after
+    /// the onLoad plugin has finished.
+    defer_copy_for_bundling: bool = false,
 
     /// The information returned to the Bundler thread when a parse finishes.
     pub const Result = struct {
@@ -3504,7 +3508,7 @@ pub const ParseTask = struct {
                 return JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
             },
             .text => {
-                const root = Expr.init(E.UTF8String, E.UTF8String{
+                const root = Expr.init(E.String, E.String{
                     .data = source.contents,
                 }, Logger.Loc{ .start = 0 });
                 var ast = JSAst.init((try js_parser.newLazyExportAST(allocator, bundler.options.define, opts, log, root, &source, "")).?);
@@ -3885,7 +3889,7 @@ pub const ParseTask = struct {
         var ast: JSAst = if (!is_empty)
             try getAST(log, bundler, opts, allocator, resolver, source, loader, task.ctx.unique_key, &unique_key_for_additional_file)
         else switch (opts.module_type == .esm) {
-            inline else => |as_undefined| if (loader == .css) try getEmptyCSSAST(
+            inline else => |as_undefined| if (loader == .css and this.ctx.bundler.options.experimental_css) try getEmptyCSSAST(
                 log,
                 bundler,
                 opts,
@@ -5017,6 +5021,10 @@ pub const LinkerContext = struct {
     dev_server: ?*bun.bake.DevServer = null,
     framework: ?*const bake.Framework = null,
 
+    fn pathWithPrettyInitialized(this: *LinkerContext, path: Fs.Path) !Fs.Path {
+        return genericPathWithPrettyInitialized(path, this.options.target, this.resolver.fs.top_level_dir, this.graph.allocator);
+    }
+
     pub const LinkerOptions = struct {
         output_format: options.Format = .esm,
         ignore_dce_annotations: bool = false,
@@ -9581,13 +9589,17 @@ pub const LinkerContext = struct {
         if (chunk.content == .javascript) {
             const sources = c.parse_graph.input_files.items(.source);
             for (chunk.content.javascript.parts_in_chunk_in_order) |part_range| {
-                const source: Logger.Source = sources[part_range.source_index.get()];
+                const source: *Logger.Source = &sources[part_range.source_index.get()];
 
                 const file_path = brk: {
                     if (source.path.isFile()) {
                         // Use the pretty path as the file name since it should be platform-
                         // independent (relative paths and the "/" path separator)
+                        if (source.path.text.ptr == source.path.pretty.ptr) {
+                            source.path = c.pathWithPrettyInitialized(source.path) catch bun.outOfMemory();
+                        }
                         source.path.assertPrettyIsValid();
+
                         break :brk source.path.pretty;
                     } else {
                         // If this isn't in the "file" namespace, just use the full path text
@@ -12305,7 +12317,8 @@ pub const LinkerContext = struct {
                     if (strings.eqlComptime(from_chunk_dir, "."))
                         from_chunk_dir = "";
 
-                    const additional_files: []AdditionalFile = c.parse_graph.input_files.items(.additional_files)[piece.query.index].slice();
+                    const source_index = piece.query.index;
+                    const additional_files: []AdditionalFile = c.parse_graph.input_files.items(.additional_files)[source_index].slice();
                     bun.assert(additional_files.len > 0);
                     switch (additional_files[0]) {
                         .output_file => |output_file_id| {
diff --git a/src/bundler/entry_points.zig b/src/bundler/entry_points.zig
index 1237f02fa4578e..ac4e4fbb70d6eb 100644
--- a/src/bundler/entry_points.zig
+++ b/src/bundler/entry_points.zig
@@ -172,28 +172,31 @@ pub const ServerEntryPoint = struct {
                 break :brk try std.fmt.allocPrint(
                     allocator,
                     \\// @bun
-                    \\var hmrSymbol = Symbol.for("BunServerHMR");
                     \\import * as start from '{}';
+                    \\var hmrSymbol = Symbol("BunServerHMR");
                     \\var entryNamespace = start;
                     \\if (typeof entryNamespace?.then === 'function') {{
                     \\   entryNamespace = entryNamespace.then((entryNamespace) => {{
-                    \\      if(typeof entryNamespace?.default?.fetch === 'function')  {{
+                    \\      var def = entryNamespace?.default;
+                    \\      if (def && (typeof def.fetch === 'function' || def.app != undefined))  {{
                     \\        var server = globalThis[hmrSymbol];
                     \\        if (server) {{
-                    \\           server.reload(entryNamespace.default);
+                    \\           server.reload(def);
+                    \\           console.debug(`Reloaded ${{server.development ? 'development ' : ''}}server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
                     \\        }} else {{
-                    \\           server = globalThis[hmrSymbol] = Bun.serve(entryNamespace.default);
-                    \\           console.debug(`Started server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
+                    \\           server = globalThis[hmrSymbol] = Bun.serve(def);
+                    \\           console.debug(`Started ${{server.development ? 'development ' : ''}}server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
                     \\        }}
                     \\      }}
                     \\   }}, reportError);
-                    \\}} else if (typeof entryNamespace?.default?.fetch === 'function') {{
+                    \\}} else if (typeof entryNamespace?.default?.fetch === 'function' || entryNamespace?.default?.app != undefined) {{
                     \\   var server = globalThis[hmrSymbol];
                     \\   if (server) {{
                     \\      server.reload(entryNamespace.default);
+                    \\      console.debug(`Reloaded ${{server.development ? 'development ' : ''}}server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
                     \\   }} else {{
                     \\      server = globalThis[hmrSymbol] = Bun.serve(entryNamespace.default);
-                    \\      console.debug(`Started server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
+                    \\      console.debug(`Started ${{server.development ? 'development ' : ''}}server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
                     \\   }}
                     \\}}
                     \\
@@ -210,12 +213,14 @@ pub const ServerEntryPoint = struct {
                 \\var entryNamespace = start;
                 \\if (typeof entryNamespace?.then === 'function') {{
                 \\   entryNamespace = entryNamespace.then((entryNamespace) => {{
-                \\      if(typeof entryNamespace?.default?.fetch === 'function')  {{
-                \\        Bun.serve(entryNamespace.default);
+                \\      if (typeof entryNamespace?.default?.fetch === 'function')  {{
+                \\        const server = Bun.serve(entryNamespace.default);
+                \\        console.debug(`Started ${{server.development ? 'development ' : ''}}server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
                 \\      }}
                 \\   }}, reportError);
-                \\}} else if (typeof entryNamespace?.default?.fetch === 'function') {{
-                \\   Bun.serve(entryNamespace.default);
+                \\}} else if (typeof entryNamespace?.default?.fetch === 'function' || entryNamespace?.default?.app != null) {{
+                \\   const server = Bun.serve(entryNamespace.default);
+                \\   console.debug(`Started ${{server.development ? 'development ' : ''}}server ${{server.protocol}}://${{server.hostname}}:${{server.port}}`);
                 \\}}
                 \\
             ,
diff --git a/src/bunfig.zig b/src/bunfig.zig
index 5be26533cbe632..f5e41c434deb0e 100644
--- a/src/bunfig.zig
+++ b/src/bunfig.zig
@@ -266,6 +266,17 @@ pub const Bunfig = struct {
                         this.ctx.test_options.coverage.enabled = expr.data.e_boolean.value;
                     }
 
+                    if (test_.get("reporter")) |expr| {
+                        try this.expect(expr, .e_object);
+                        if (expr.get("junit")) |junit_expr| {
+                            try this.expectString(junit_expr);
+                            if (junit_expr.data.e_string.len() > 0) {
+                                this.ctx.test_options.file_reporter = .junit;
+                                this.ctx.test_options.reporter_outfile = try junit_expr.data.e_string.string(allocator);
+                            }
+                        }
+                    }
+
                     if (test_.get("coverageReporter")) |expr| brk: {
                         this.ctx.test_options.coverage.reporters = .{ .text = false, .lcov = false };
                         if (expr.data == .e_string) {
@@ -797,7 +808,7 @@ pub const Bunfig = struct {
 
         pub fn expectString(this: *Parser, expr: js_ast.Expr) !void {
             switch (expr.data) {
-                .e_string, .e_utf8_string => {},
+                .e_string => {},
                 else => {
                     this.log.addErrorFmtOpts(
                         this.allocator,
diff --git a/src/cli.zig b/src/cli.zig
index 19f64c55e1a98e..a28b799b5e36ce 100644
--- a/src/cli.zig
+++ b/src/cli.zig
@@ -182,11 +182,12 @@ pub const Arguments = struct {
         clap.parseParam("--cwd <STR>                       Absolute path to resolve files & entry points from. This just changes the process' cwd.") catch unreachable,
         clap.parseParam("-c, --config <PATH>?              Specify path to Bun config file. Default <d>$cwd<r>/bunfig.toml") catch unreachable,
         clap.parseParam("-h, --help                        Display this menu and exit") catch unreachable,
-        clap.parseParam("<POS>...") catch unreachable,
-    } ++ if (builtin.have_error_return_tracing) [_]ParamType{
+    } ++ (if (builtin.have_error_return_tracing) [_]ParamType{
         // This will print more error return traces, as a debug aid
-        clap.parseParam("--verbose-error-trace") catch unreachable,
-    } else [_]ParamType{};
+        clap.parseParam("--verbose-error-trace             Dump error return traces") catch unreachable,
+    } else [_]ParamType{}) ++ [_]ParamType{
+        clap.parseParam("<POS>...") catch unreachable,
+    };
 
     const debug_params = [_]ParamType{
         clap.parseParam("--breakpoint-resolve <STR>...     DEBUG MODE: breakpoint when resolving something that includes this string") catch unreachable,
@@ -305,6 +306,8 @@ pub const Arguments = struct {
         clap.parseParam("--coverage-dir <STR>             Directory for coverage files. Defaults to 'coverage'.") catch unreachable,
         clap.parseParam("--bail <NUMBER>?                 Exit the test suite after <NUMBER> failures. If you do not specify a number, it defaults to 1.") catch unreachable,
         clap.parseParam("-t, --test-name-pattern <STR>    Run only tests with a name that matches the given regex.") catch unreachable,
+        clap.parseParam("--reporter <STR>                 Specify the test reporter. Currently --reporter=junit is the only supported format.") catch unreachable,
+        clap.parseParam("--reporter-outfile <STR>         The output file used for the format from --reporter.") catch unreachable,
     };
     pub const test_params = test_only_params ++ runtime_params_ ++ transpiler_params_ ++ base_params_;
 
@@ -523,6 +526,23 @@ pub const Arguments = struct {
                 }
             }
 
+            if (args.option("--reporter-outfile")) |reporter_outfile| {
+                ctx.test_options.reporter_outfile = reporter_outfile;
+            }
+
+            if (args.option("--reporter")) |reporter| {
+                if (strings.eqlComptime(reporter, "junit")) {
+                    if (ctx.test_options.reporter_outfile == null) {
+                        Output.errGeneric("--reporter=junit expects an output file from --reporter-outfile", .{});
+                        Global.crash();
+                    }
+                    ctx.test_options.file_reporter = .junit;
+                } else {
+                    Output.errGeneric("unrecognized reporter format: '{s}'. Currently, only 'junit' is supported", .{reporter});
+                    Global.crash();
+                }
+            }
+
             if (args.option("--coverage-dir")) |dir| {
                 ctx.test_options.coverage.reports_directory = dir;
             }
@@ -769,11 +789,9 @@ pub const Arguments = struct {
             ctx.bundler_options.transform_only = args.flag("--no-bundle");
             ctx.bundler_options.bytecode = args.flag("--bytecode");
 
-            if (comptime FeatureFlags.bake) {
-                if (args.flag("--app")) {
-                    ctx.bundler_options.bake = true;
-                    ctx.bundler_options.bake_debug_dump_server = args.flag("--debug-dump-server-files");
-                }
+            if (FeatureFlags.bake and args.flag("--app")) {
+                ctx.bundler_options.bake = true;
+                ctx.bundler_options.bake_debug_dump_server = args.flag("--debug-dump-server-files");
             }
 
             // TODO: support --format=esm
@@ -935,18 +953,12 @@ pub const Arguments = struct {
                 ctx.bundler_options.asset_naming = try strings.concat(allocator, &.{ "./", bun.strings.removeLeadingDotSlash(asset_naming) });
             }
 
-            if (comptime FeatureFlags.bake) {
-                if (args.flag("--server-components")) {
-                    if (!bun.FeatureFlags.cli_server_components) {
-                        // TODO: i want to disable this in non-canary
-                        // but i also want to have tests that can run for PRs
-                    }
-                    ctx.bundler_options.server_components = true;
-                    if (opts.target) |target| {
-                        if (!bun.options.Target.from(target).isServerSide()) {
-                            bun.Output.errGeneric("Cannot use client-side --target={s} with --server-components", .{@tagName(target)});
-                            Global.crash();
-                        }
+            if (bun.FeatureFlags.bake and args.flag("--server-components")) {
+                ctx.bundler_options.server_components = true;
+                if (opts.target) |target| {
+                    if (!bun.options.Target.from(target).isServerSide()) {
+                        bun.Output.errGeneric("Cannot use client-side --target={s} with --server-components", .{@tagName(target)});
+                        Global.crash();
                     } else {
                         opts.target = .bun;
                     }
@@ -1361,6 +1373,9 @@ pub const Command = struct {
         bail: u32 = 0,
         coverage: TestCommand.CodeCoverageOptions = .{},
         test_filter_regex: ?*RegularExpression = null,
+
+        file_reporter: ?TestCommand.FileReporter = null,
+        reporter_outfile: ?[]const u8 = null,
     };
 
     pub const Debugger = union(enum) {
diff --git a/src/cli/install.sh b/src/cli/install.sh
index 08a0817f6d6060..f32e0732585428 100644
--- a/src/cli/install.sh
+++ b/src/cli/install.sh
@@ -78,6 +78,14 @@ case $platform in
     ;;
 esac
 
+case "$target" in
+'linux'*)
+    if [ -f /etc/alpine-release ]; then
+        target="$target-musl"
+    fi
+    ;;
+esac
+
 if [[ $target = darwin-x64 ]]; then
     # Is this process running in Rosetta?
     # redirect stderr to devnull to avoid error message when not running in Rosetta
@@ -91,19 +99,20 @@ GITHUB=${GITHUB-"https://github.com"}
 
 github_repo="$GITHUB/oven-sh/bun"
 
-if [[ $target = darwin-x64 ]]; then
-    # If AVX2 isn't supported, use the -baseline build
+# If AVX2 isn't supported, use the -baseline build
+case "$target" in
+'darwin-x64'*)
     if [[ $(sysctl -a | grep machdep.cpu | grep AVX2) == '' ]]; then
-        target=darwin-x64-baseline
+        target="$target-baseline"
     fi
-fi
-
-if [[ $target = linux-x64 ]]; then
+    ;;
+'linux-x64'*)
     # If AVX2 isn't supported, use the -baseline build
     if [[ $(cat /proc/cpuinfo | grep avx2) = '' ]]; then
-        target=linux-x64-baseline
+        target="$target-baseline"
     fi
-fi
+    ;;
+esac
 
 exe_name=bun
 
diff --git a/src/cli/outdated_command.zig b/src/cli/outdated_command.zig
index 7e51e94fef01d6..51d1e088b00c8e 100644
--- a/src/cli/outdated_command.zig
+++ b/src/cli/outdated_command.zig
@@ -590,7 +590,7 @@ pub const OutdatedCommand = struct {
 
                     var task = manager.getNetworkTask();
                     task.* = .{
-                        .package_manager = &PackageManager.instance,
+                        .package_manager = PackageManager.get(),
                         .callback = undefined,
                         .task_id = task_id,
                         .allocator = manager.allocator,
diff --git a/src/cli/pack_command.zig b/src/cli/pack_command.zig
index 7645912fef63fa..02d43702a1ebb8 100644
--- a/src/cli/pack_command.zig
+++ b/src/cli/pack_command.zig
@@ -2297,7 +2297,7 @@ pub const bindings = struct {
     //     return obj;
     // }
 
-    pub fn jsReadTarball(global: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+    pub fn jsReadTarball(global: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
         const args = callFrame.arguments(1).slice();
         if (args.len < 1 or !args[0].isString()) {
             global.throw("expected tarball path string argument", .{});
diff --git a/src/cli/run_command.zig b/src/cli/run_command.zig
index d24ef3600a89cd..3267b38de8217c 100644
--- a/src/cli/run_command.zig
+++ b/src/cli/run_command.zig
@@ -194,7 +194,6 @@ pub const RunCommand = struct {
                     delimiter = 0;
                 },
 
-                // do we need to escape?
                 ' ' => {
                     delimiter = ' ';
                 },
@@ -236,24 +235,6 @@ pub const RunCommand = struct {
 
                     delimiter = 0;
                 },
-                // TODO: handle escape sequences properly
-                // https://github.com/oven-sh/bun/issues/53
-                '\\' => {
-                    delimiter = 0;
-
-                    if (entry_i + 1 < script.len) {
-                        switch (script[entry_i + 1]) {
-                            '"', '\'' => {
-                                entry_i += 1;
-                                continue;
-                            },
-                            '\\' => {
-                                entry_i += 1;
-                            },
-                            else => {},
-                        }
-                    }
-                },
                 else => {
                     delimiter = 0;
                 },
diff --git a/src/cli/test_command.zig b/src/cli/test_command.zig
index 451f1e2a529269..cfe25b04792c56 100644
--- a/src/cli/test_command.zig
+++ b/src/cli/test_command.zig
@@ -9,6 +9,7 @@ const stringZ = bun.stringZ;
 const default_allocator = bun.default_allocator;
 const C = bun.C;
 const std = @import("std");
+const OOM = bun.OOM;
 
 const lex = bun.js_lexer;
 const logger = bun.logger;
@@ -45,6 +46,44 @@ const Test = TestRunner.Test;
 const CodeCoverageReport = bun.sourcemap.CodeCoverageReport;
 const uws = bun.uws;
 
+fn escapeXml(str: string, writer: anytype) !void {
+    var last: usize = 0;
+    var i: usize = 0;
+    const len = str.len;
+    while (i < len) : (i += 1) {
+        const c = str[i];
+        switch (c) {
+            '&',
+            '<',
+            '>',
+            '"',
+            '\'',
+            => {
+                if (i > last) {
+                    try writer.writeAll(str[last..i]);
+                }
+                const escaped = switch (c) {
+                    '&' => "&amp;",
+                    '<' => "&lt;",
+                    '>' => "&gt;",
+                    '"' => "&quot;",
+                    '\'' => "&apos;",
+                    else => unreachable,
+                };
+                try writer.writeAll(escaped);
+                last = i + 1;
+            },
+            0...0x1f => {
+                // Escape all control characters
+                try writer.print("&#{d};", .{c});
+            },
+            else => {},
+        }
+    }
+    if (len > last) {
+        try writer.writeAll(str[last..]);
+    }
+}
 fn fmtStatusTextLine(comptime status: @Type(.EnumLiteral), comptime emoji_or_color: bool) []const u8 {
     comptime {
         // emoji and color might be split into two different options in the future
@@ -76,6 +115,357 @@ fn writeTestStatusLine(comptime status: @Type(.EnumLiteral), writer: anytype) vo
         writer.print(fmtStatusTextLine(status, false), .{}) catch unreachable;
 }
 
+// Remaining TODOs:
+// - Add stdout/stderr to the JUnit report
+// - Add timestamp field to the JUnit report
+pub const JunitReporter = struct {
+    contents: std.ArrayListUnmanaged(u8) = .{},
+    total_metrics: Metrics = .{},
+    testcases_metrics: Metrics = .{},
+    offset_of_testsuites_value: usize = 0,
+    offset_of_testsuite_value: usize = 0,
+    current_file: string = "",
+    properties_list_to_repeat_in_every_test_suite: ?[]const u8 = null,
+
+    hostname_value: ?string = null,
+
+    pub fn getHostname(this: *JunitReporter) ?string {
+        if (this.hostname_value == null) {
+            if (Environment.isWindows) {
+                return null;
+            }
+
+            var name_buffer: [bun.HOST_NAME_MAX]u8 = undefined;
+            const hostname = std.posix.gethostname(&name_buffer) catch {
+                this.hostname_value = "";
+                return null;
+            };
+
+            var arraylist_writer = std.ArrayList(u8).init(bun.default_allocator);
+            escapeXml(hostname, arraylist_writer.writer()) catch {
+                this.hostname_value = "";
+                return null;
+            };
+            this.hostname_value = arraylist_writer.items;
+        }
+
+        if (this.hostname_value) |hostname| {
+            if (hostname.len > 0) {
+                return hostname;
+            }
+        }
+        return null;
+    }
+
+    const Metrics = struct {
+        test_cases: u32 = 0,
+        assertions: u32 = 0,
+        failures: u32 = 0,
+        skipped: u32 = 0,
+        elapsed_time: u64 = 0,
+
+        pub fn add(this: *Metrics, other: *const Metrics) void {
+            this.test_cases += other.test_cases;
+            this.assertions += other.assertions;
+            this.failures += other.failures;
+            this.skipped += other.skipped;
+        }
+    };
+    pub fn init() *JunitReporter {
+        return JunitReporter.new(
+            .{ .contents = .{}, .total_metrics = .{} },
+        );
+    }
+
+    pub usingnamespace bun.New(JunitReporter);
+
+    fn generatePropertiesList(this: *JunitReporter) !void {
+        const PropertiesList = struct {
+            ci: string,
+            commit: string,
+        };
+        var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+        defer arena.deinit();
+        var stack = std.heap.stackFallback(1024, arena.allocator());
+        const allocator = stack.get();
+
+        const properties: PropertiesList = .{
+            .ci = brk: {
+                if (bun.getenvZ("GITHUB_RUN_ID")) |github_run_id| {
+                    if (bun.getenvZ("GITHUB_SERVER_URL")) |github_server_url| {
+                        if (bun.getenvZ("GITHUB_REPOSITORY")) |github_repository| {
+                            if (github_run_id.len > 0 and github_server_url.len > 0 and github_repository.len > 0) {
+                                break :brk try std.fmt.allocPrint(allocator, "{s}/{s}/actions/runs/{s}", .{ github_server_url, github_repository, github_run_id });
+                            }
+                        }
+                    }
+                }
+
+                if (bun.getenvZ("CI_JOB_URL")) |ci_job_url| {
+                    if (ci_job_url.len > 0) {
+                        break :brk ci_job_url;
+                    }
+                }
+
+                break :brk "";
+            },
+            .commit = brk: {
+                if (bun.getenvZ("GITHUB_SHA")) |github_sha| {
+                    if (github_sha.len > 0) {
+                        break :brk github_sha;
+                    }
+                }
+
+                if (bun.getenvZ("CI_COMMIT_SHA")) |sha| {
+                    if (sha.len > 0) {
+                        break :brk sha;
+                    }
+                }
+
+                if (bun.getenvZ("GIT_SHA")) |git_sha| {
+                    if (git_sha.len > 0) {
+                        break :brk git_sha;
+                    }
+                }
+
+                break :brk "";
+            },
+        };
+
+        if (properties.ci.len == 0 and properties.commit.len == 0) {
+            this.properties_list_to_repeat_in_every_test_suite = "";
+            return;
+        }
+
+        var buffer = std.ArrayList(u8).init(bun.default_allocator);
+        var writer = buffer.writer();
+
+        try writer.writeAll(
+            \\    <properties>
+            \\
+        );
+
+        if (properties.ci.len > 0) {
+            try writer.writeAll(
+                \\      <property name="ci" value="
+            );
+            try escapeXml(properties.ci, writer);
+            try writer.writeAll("\" />\n");
+        }
+        if (properties.commit.len > 0) {
+            try writer.writeAll(
+                \\      <property name="commit" value="
+            );
+            try escapeXml(properties.commit, writer);
+            try writer.writeAll("\" />\n");
+        }
+
+        try writer.writeAll("    </properties>\n");
+
+        this.properties_list_to_repeat_in_every_test_suite = buffer.items;
+    }
+
+    pub fn beginTestSuite(this: *JunitReporter, name: string) !void {
+        if (this.contents.items.len == 0) {
+            try this.contents.appendSlice(bun.default_allocator,
+                \\<?xml version="1.0" encoding="UTF-8"?>
+                \\
+            );
+
+            try this.contents.appendSlice(bun.default_allocator,
+                \\<testsuites name="bun test" 
+            );
+            this.offset_of_testsuites_value = this.contents.items.len;
+            try this.contents.appendSlice(bun.default_allocator, ">\n");
+        }
+
+        try this.contents.appendSlice(bun.default_allocator,
+            \\  <testsuite name="
+        );
+
+        try escapeXml(name, this.contents.writer(bun.default_allocator));
+
+        try this.contents.appendSlice(bun.default_allocator, "\" ");
+        this.offset_of_testsuite_value = this.contents.items.len;
+        try this.contents.appendSlice(bun.default_allocator, ">\n");
+
+        if (this.properties_list_to_repeat_in_every_test_suite == null) {
+            try this.generatePropertiesList();
+        }
+
+        if (this.properties_list_to_repeat_in_every_test_suite) |properties_list| {
+            if (properties_list.len > 0) {
+                try this.contents.appendSlice(bun.default_allocator, properties_list);
+            }
+        }
+
+        this.current_file = name;
+    }
+
+    pub fn endTestSuite(this: *JunitReporter) !void {
+        var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+        defer arena.deinit();
+        var stack_fallback_allocator = std.heap.stackFallback(4096, arena.allocator());
+        const allocator = stack_fallback_allocator.get();
+
+        const metrics = &this.testcases_metrics;
+        this.total_metrics.add(metrics);
+
+        const elapsed_time_ms = metrics.elapsed_time;
+        const elapsed_time_ms_f64: f64 = @floatFromInt(elapsed_time_ms);
+        const elapsed_time_seconds = elapsed_time_ms_f64 / std.time.ms_per_s;
+
+        // Insert the summary attributes
+        const summary = try std.fmt.allocPrint(allocator,
+            \\tests="{d}" assertions="{d}" failures="{d}" skipped="{d}" time="{d}" hostname="{s}"
+        , .{
+            metrics.test_cases,
+            metrics.assertions,
+            metrics.failures,
+            metrics.skipped,
+            elapsed_time_seconds,
+            this.getHostname() orelse "",
+        });
+        this.testcases_metrics = .{};
+        this.contents.insertSlice(bun.default_allocator, this.offset_of_testsuite_value, summary) catch bun.outOfMemory();
+
+        try this.contents.appendSlice(bun.default_allocator, "  </testsuite>\n");
+    }
+
+    pub fn writeTestCase(
+        this: *JunitReporter,
+        status: TestRunner.Test.Status,
+        file: string,
+        name: string,
+        class_name: string,
+        assertions: u32,
+        elapsed_ns: u64,
+    ) !void {
+        const elapsed_ns_f64: f64 = @floatFromInt(elapsed_ns);
+        const elapsed_ms = elapsed_ns_f64 / std.time.ns_per_ms;
+        this.testcases_metrics.elapsed_time +|= @as(u64, @intFromFloat(elapsed_ms));
+        this.testcases_metrics.test_cases += 1;
+
+        try this.contents.appendSlice(bun.default_allocator, "    <testcase");
+        try this.contents.appendSlice(bun.default_allocator, " name=\"");
+        try escapeXml(name, this.contents.writer(bun.default_allocator));
+        try this.contents.appendSlice(bun.default_allocator, "\" classname=\"");
+        try escapeXml(class_name, this.contents.writer(bun.default_allocator));
+        try this.contents.appendSlice(bun.default_allocator, "\"");
+
+        const elapsed_seconds = elapsed_ms / std.time.ms_per_s;
+        var time_buf: [32]u8 = undefined;
+        const time_str = try std.fmt.bufPrint(&time_buf, " time=\"{d}\"", .{elapsed_seconds});
+        try this.contents.appendSlice(bun.default_allocator, time_str);
+
+        try this.contents.appendSlice(bun.default_allocator, " file=\"");
+        try escapeXml(file, this.contents.writer(bun.default_allocator));
+        try this.contents.appendSlice(bun.default_allocator, "\"");
+
+        try this.contents.writer(bun.default_allocator).print(" assertions=\"{d}\"", .{assertions});
+
+        this.testcases_metrics.assertions += assertions;
+
+        switch (status) {
+            .pass => {
+                try this.contents.appendSlice(bun.default_allocator, " />\n");
+            },
+            .fail => {
+                this.testcases_metrics.failures += 1;
+                try this.contents.appendSlice(bun.default_allocator, ">\n      <failure type=\"AssertionError\" />\n    </testcase>\n");
+                // TODO: add the failure message
+                // if (failure_message) |msg| {
+                //     try this.contents.appendSlice(bun.default_allocator, " message=\"");
+                //     try escapeXml(msg, this.contents.writer(bun.default_allocator));
+                //     try this.contents.appendSlice(bun.default_allocator, "\"");
+                // }
+            },
+            .fail_because_expected_assertion_count => {
+                this.testcases_metrics.failures += 1;
+                // TODO: add the failure message
+                try this.contents.writer(bun.default_allocator).print(
+                    \\>
+                    \\      <failure message="Expected more assertions, but only received {d}" type="AssertionError"/>
+                    \\    </testcase>
+                , .{assertions});
+            },
+            .fail_because_todo_passed => {
+                this.testcases_metrics.failures += 1;
+                // TODO: add the failure message
+                try this.contents.writer(bun.default_allocator).print(
+                    \\>
+                    \\      <failure message="TODO passed" type="AssertionError"/>
+                    \\    </testcase>
+                , .{});
+            },
+            .fail_because_expected_has_assertions => {
+                this.testcases_metrics.failures += 1;
+                try this.contents.writer(bun.default_allocator).print(
+                    \\>
+                    \\      <failure message="Expected to have assertions, but none were run" type="AssertionError"/>
+                    \\    </testcase>
+                , .{});
+            },
+            .skip => {
+                this.testcases_metrics.skipped += 1;
+                try this.contents.appendSlice(bun.default_allocator, ">\n      <skipped />\n    </testcase>\n");
+            },
+            .todo => {
+                this.testcases_metrics.skipped += 1;
+                try this.contents.appendSlice(bun.default_allocator, ">\n      <skipped message=\"TODO\" />\n    </testcase>\n");
+            },
+            .pending => unreachable,
+        }
+    }
+
+    pub fn writeToFile(this: *JunitReporter, path: string) !void {
+        if (this.contents.items.len == 0) return;
+        {
+            var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+            defer arena.deinit();
+            var stack_fallback_allocator = std.heap.stackFallback(4096, arena.allocator());
+            const allocator = stack_fallback_allocator.get();
+            const metrics = this.total_metrics;
+            const elapsed_time = @as(f64, @floatFromInt(std.time.nanoTimestamp() - bun.start_time)) / std.time.ns_per_s;
+            const summary = try std.fmt.allocPrint(allocator,
+                \\tests="{d}" assertions="{d}" failures="{d}" skipped="{d}" time="{d}"
+            , .{
+                metrics.test_cases,
+                metrics.assertions,
+                metrics.failures,
+                metrics.skipped,
+                elapsed_time,
+            });
+            this.contents.insertSlice(bun.default_allocator, this.offset_of_testsuites_value, summary) catch bun.outOfMemory();
+            this.contents.appendSlice(bun.default_allocator, "</testsuites>\n") catch bun.outOfMemory();
+        }
+
+        var junit_path_buf: bun.PathBuffer = undefined;
+
+        @memcpy(junit_path_buf[0..path.len], path);
+        junit_path_buf[path.len] = 0;
+
+        switch (bun.sys.File.openat(std.fs.cwd(), junit_path_buf[0..path.len :0], bun.O.WRONLY | bun.O.CREAT | bun.O.TRUNC, 0o664)) {
+            .err => |err| {
+                Output.err(error.JUnitReportFailed, "Failed to write JUnit report to {s}\n{}", .{ path, err });
+            },
+            .result => |fd| {
+                defer _ = fd.close();
+                switch (bun.sys.File.writeAll(fd, this.contents.items)) {
+                    .result => {},
+                    .err => |err| {
+                        Output.err(error.JUnitReportFailed, "Failed to write JUnit report to {s}\n{}", .{ path, err });
+                    },
+                }
+            },
+        }
+    }
+
+    pub fn deinit(this: *JunitReporter) void {
+        this.contents.deinit(bun.default_allocator);
+    }
+};
+
 pub const CommandLineReporter = struct {
     jest: TestRunner,
     callback: TestRunner.Callback,
@@ -88,6 +478,12 @@ pub const CommandLineReporter = struct {
     skips_to_repeat_buf: std.ArrayListUnmanaged(u8) = .{},
     todos_to_repeat_buf: std.ArrayListUnmanaged(u8) = .{},
 
+    file_reporter: ?FileReporter = null,
+
+    pub const FileReporter = union(enum) {
+        junit: *JunitReporter,
+    };
+
     pub const Summary = struct {
         pass: u32 = 0,
         expectations: u32 = 0,
@@ -110,7 +506,17 @@ pub const CommandLineReporter = struct {
 
     pub fn handleTestStart(_: *TestRunner.Callback, _: Test.ID) void {}
 
-    fn printTestLine(label: string, elapsed_ns: u64, parent: ?*jest.DescribeScope, comptime skip: bool, writer: anytype) void {
+    fn printTestLine(
+        status: TestRunner.Test.Status,
+        label: string,
+        elapsed_ns: u64,
+        parent: ?*jest.DescribeScope,
+        assertions: u32,
+        comptime skip: bool,
+        writer: anytype,
+        file: string,
+        file_reporter: ?FileReporter,
+    ) void {
         var scopes_stack = std.BoundedArray(*jest.DescribeScope, 64).init(0) catch unreachable;
         var parent_ = parent;
 
@@ -165,9 +571,51 @@ pub const CommandLineReporter = struct {
         }
 
         writer.writeAll("\n") catch unreachable;
+
+        if (file_reporter) |reporter| {
+            switch (reporter) {
+                .junit => |junit| {
+                    const filename = brk: {
+                        if (strings.hasPrefix(file, bun.fs.FileSystem.instance.top_level_dir)) {
+                            break :brk strings.withoutLeadingPathSeparator(file[bun.fs.FileSystem.instance.top_level_dir.len..]);
+                        } else {
+                            break :brk file;
+                        }
+                    };
+                    if (!strings.eql(junit.current_file, filename)) {
+                        if (junit.current_file.len > 0) {
+                            junit.endTestSuite() catch bun.outOfMemory();
+                        }
+
+                        junit.beginTestSuite(filename) catch bun.outOfMemory();
+                    }
+
+                    var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
+                    defer arena.deinit();
+                    var stack_fallback = std.heap.stackFallback(4096, arena.allocator());
+                    const allocator = stack_fallback.get();
+                    var concatenated_describe_scopes = std.ArrayList(u8).init(allocator);
+
+                    {
+                        const initial_length = concatenated_describe_scopes.items.len;
+                        for (scopes) |scope| {
+                            if (scope.label.len > 0) {
+                                if (initial_length != concatenated_describe_scopes.items.len) {
+                                    concatenated_describe_scopes.appendSlice(" &gt; ") catch bun.outOfMemory();
+                                }
+
+                                escapeXml(scope.label, concatenated_describe_scopes.writer()) catch bun.outOfMemory();
+                            }
+                        }
+                    }
+
+                    junit.writeTestCase(status, filename, display_label, concatenated_describe_scopes.items, assertions, elapsed_ns) catch bun.outOfMemory();
+                },
+            }
+        }
     }
 
-    pub fn handleTestPass(cb: *TestRunner.Callback, id: Test.ID, _: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
+    pub fn handleTestPass(cb: *TestRunner.Callback, id: Test.ID, file: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
         const writer_ = Output.errorWriter();
         var buffered_writer = std.io.bufferedWriter(writer_);
         var writer = buffered_writer.writer();
@@ -177,14 +625,14 @@ pub const CommandLineReporter = struct {
 
         writeTestStatusLine(.pass, &writer);
 
-        printTestLine(label, elapsed_ns, parent, false, writer);
+        printTestLine(.pass, label, elapsed_ns, parent, expectations, false, writer, file, this.file_reporter);
 
         this.jest.tests.items(.status)[id] = TestRunner.Test.Status.pass;
         this.summary.pass += 1;
         this.summary.expectations += expectations;
     }
 
-    pub fn handleTestFail(cb: *TestRunner.Callback, id: Test.ID, _: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
+    pub fn handleTestFail(cb: *TestRunner.Callback, id: Test.ID, file: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
         var writer_ = Output.errorWriter();
         var this: *CommandLineReporter = @fieldParentPtr("callback", cb);
 
@@ -194,7 +642,7 @@ pub const CommandLineReporter = struct {
         var writer = this.failures_to_repeat_buf.writer(bun.default_allocator);
 
         writeTestStatusLine(.fail, &writer);
-        printTestLine(label, elapsed_ns, parent, false, writer);
+        printTestLine(.fail, label, elapsed_ns, parent, expectations, false, writer, file, this.file_reporter);
 
         // We must always reset the colors because (skip) will have set them to <d>
         if (Output.enable_ansi_colors_stderr) {
@@ -217,7 +665,7 @@ pub const CommandLineReporter = struct {
         }
     }
 
-    pub fn handleTestSkip(cb: *TestRunner.Callback, id: Test.ID, _: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
+    pub fn handleTestSkip(cb: *TestRunner.Callback, id: Test.ID, file: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
         var writer_ = Output.errorWriter();
         var this: *CommandLineReporter = @fieldParentPtr("callback", cb);
 
@@ -229,7 +677,7 @@ pub const CommandLineReporter = struct {
             var writer = this.skips_to_repeat_buf.writer(bun.default_allocator);
 
             writeTestStatusLine(.skip, &writer);
-            printTestLine(label, elapsed_ns, parent, true, writer);
+            printTestLine(.skip, label, elapsed_ns, parent, expectations, true, writer, file, this.file_reporter);
 
             writer_.writeAll(this.skips_to_repeat_buf.items[initial_length..]) catch unreachable;
             Output.flush();
@@ -241,7 +689,7 @@ pub const CommandLineReporter = struct {
         this.jest.tests.items(.status)[id] = TestRunner.Test.Status.skip;
     }
 
-    pub fn handleTestTodo(cb: *TestRunner.Callback, id: Test.ID, _: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
+    pub fn handleTestTodo(cb: *TestRunner.Callback, id: Test.ID, file: string, label: string, expectations: u32, elapsed_ns: u64, parent: ?*jest.DescribeScope) void {
         var writer_ = Output.errorWriter();
 
         var this: *CommandLineReporter = @fieldParentPtr("callback", cb);
@@ -252,7 +700,7 @@ pub const CommandLineReporter = struct {
         var writer = this.todos_to_repeat_buf.writer(bun.default_allocator);
 
         writeTestStatusLine(.todo, &writer);
-        printTestLine(label, elapsed_ns, parent, true, writer);
+        printTestLine(.todo, label, elapsed_ns, parent, expectations, true, writer, file, this.file_reporter);
 
         writer_.writeAll(this.todos_to_repeat_buf.items[initial_length..]) catch unreachable;
         Output.flush();
@@ -723,6 +1171,10 @@ pub const TestCommand = struct {
         lcov: bool,
     };
 
+    pub const FileReporter = enum {
+        junit,
+    };
+
     pub fn exec(ctx: Command.Context) !void {
         if (comptime is_bindgen) unreachable;
 
@@ -782,6 +1234,13 @@ pub const TestCommand = struct {
         reporter.jest.callback = &reporter.callback;
         jest.Jest.runner = &reporter.jest;
         reporter.jest.test_options = &ctx.test_options;
+
+        if (ctx.test_options.file_reporter) |file_reporter| {
+            reporter.file_reporter = switch (file_reporter) {
+                .junit => .{ .junit = JunitReporter.init() },
+            };
+        }
+
         js_ast.Expr.Data.Store.create();
         js_ast.Stmt.Data.Store.create();
         var vm = try JSC.VirtualMachine.init(
@@ -1089,6 +1548,17 @@ pub const TestCommand = struct {
         Output.prettyError("\n", .{});
         Output.flush();
 
+        if (reporter.file_reporter) |file_reporter| {
+            switch (file_reporter) {
+                .junit => |junit| {
+                    if (junit.current_file.len > 0) {
+                        junit.endTestSuite() catch {};
+                    }
+                    junit.writeToFile(ctx.test_options.reporter_outfile.?) catch {};
+                },
+            }
+        }
+
         if (vm.hot_reload == .watch) {
             vm.eventLoop().tickPossiblyForever();
 
diff --git a/src/cli/upgrade_command.zig b/src/cli/upgrade_command.zig
index 8b337f15f982f1..d55776ad2429ab 100644
--- a/src/cli/upgrade_command.zig
+++ b/src/cli/upgrade_command.zig
@@ -87,7 +87,9 @@ pub const Version = struct {
 
     pub const arch_label = if (Environment.isAarch64) "aarch64" else "x64";
     pub const triplet = platform_label ++ "-" ++ arch_label;
-    const suffix = if (Environment.baseline) "-baseline" else "";
+    const suffix_abi = if (Environment.isMusl) "-musl" else "";
+    const suffix_cpu = if (Environment.baseline) "-baseline" else "";
+    const suffix = suffix_abi ++ suffix_cpu;
     pub const folder_name = "bun-" ++ triplet ++ suffix;
     pub const baseline_folder_name = "bun-" ++ triplet ++ "-baseline";
     pub const zip_filename = folder_name ++ ".zip";
@@ -988,7 +990,7 @@ pub const upgrade_js_bindings = struct {
 
     /// For testing upgrades when the temp directory has an open handle without FILE_SHARE_DELETE.
     /// Windows only
-    pub fn jsOpenTempDirWithoutSharingDelete(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSC.JSValue {
+    pub fn jsOpenTempDirWithoutSharingDelete(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!bun.JSC.JSValue {
         if (comptime !Environment.isWindows) return .undefined;
         const w = std.os.windows;
 
@@ -1042,7 +1044,7 @@ pub const upgrade_js_bindings = struct {
         return .undefined;
     }
 
-    pub fn jsCloseTempDirHandle(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn jsCloseTempDirHandle(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         if (comptime !Environment.isWindows) return .undefined;
 
         if (tempdir_fd) |fd| {
diff --git a/src/codegen/bake-codegen.ts b/src/codegen/bake-codegen.ts
index bbc2050c53766c..bd8a6b8eddaf97 100644
--- a/src/codegen/bake-codegen.ts
+++ b/src/codegen/bake-codegen.ts
@@ -28,7 +28,7 @@ process.chdir(base_dir); // to make bun build predictable in development
 function convertZigEnum(zig: string) {
   const startTrigger = "\npub const MessageId = enum(u8) {";
   const start = zig.indexOf(startTrigger) + startTrigger.length;
-  const endTrigger = /\n    pub fn |\n};/g;
+  const endTrigger = /\n    pub (inline )?fn |\n};/g;
   const end = zig.slice(start).search(endTrigger) + start;
   const enumText = zig.slice(start, end);
   const values = enumText.replaceAll("\n    ", "\n  ").replace(/\n\s*(\w+)\s*=\s*'(.+?)',/g, (_, name, value) => {
@@ -53,6 +53,7 @@ async function run() {
         minify: {
           syntax: true,
         },
+        target: side === 'server' ? 'bun' : 'browser',
       });
       if (!result.success) throw new AggregateError(result.logs);
       assert(result.outputs.length === 1, "must bundle to a single file");
@@ -65,6 +66,8 @@ async function run() {
         file !== "error" && "input_graph",
         file !== "error" && "config",
         file === "server" && "server_exports",
+        file === "server" && "$separateSSRGraph",
+        file === "server" && "$importMeta",
       ].filter(Boolean);
       const combined_source =
         file === "error"
@@ -93,6 +96,10 @@ async function run() {
 
       rmSync(generated_entrypoint);
 
+      if (code.includes('export default ')) {
+        throw new AggregateError([new Error('export default is not allowed in bake codegen. this became a commonjs module!')]);
+      }
+
       if (file !== "error") {
         let names: string = "";
         code = code
@@ -102,6 +109,12 @@ async function run() {
           })
           .trim();
         assert(names, "missing name");
+        const split_names = names.split(",").map(x => x.trim());
+        const out_names = Object.fromEntries(in_names.map((x, i) => [x, split_names[i]]));
+        function outName(name) {
+          if (!out_names[name]) throw new Error(`missing out name for ${name}`);
+          return out_names[name];
+        }
 
         if (debug) {
           code = "\n  " + code.replace(/\n/g, "\n  ") + "\n";
@@ -110,14 +123,17 @@ async function run() {
         if (code[code.length - 1] === ";") code = code.slice(0, -1);
 
         if (side === "server") {
-          const server_fetch_function = names.split(",")[2].trim();
-          code = debug ? `${code}  return ${server_fetch_function};\n` : `${code};return ${server_fetch_function};`;
-        }
+          code = debug 
+            ? `${code}  return ${outName('server_exports')};\n`
+            : `${code};return ${outName('server_exports')};`;
 
-        code = debug ? `((${names}) => {${code}})({\n` : `((${names})=>{${code}})({`;
+          const params = `${outName('$separateSSRGraph')},${outName('$importMeta')}`;
+          code = code.replaceAll('import.meta', outName('$importMeta'));
+          code = `let ${outName('input_graph')}={},${outName('config')}={separateSSRGraph:${outName('$separateSSRGraph')}},${outName('server_exports')};${code}`;
 
-        if (side === "server") {
-          code = `export default await ${code}`;
+          code = debug ? `((${params}) => {${code}})\n` : `((${params})=>{${code}})\n`;
+        } else {
+          code = debug ? `((${names}) => {${code}})({\n` : `((${names})=>{${code}})({`;
         }
       }
 
diff --git a/src/codegen/bundle-functions.ts b/src/codegen/bundle-functions.ts
index 0ada057c1f7ba3..7756e44afdced7 100644
--- a/src/codegen/bundle-functions.ts
+++ b/src/codegen/bundle-functions.ts
@@ -221,6 +221,7 @@ $$capture_start$$(${fn.async ? "async " : ""}${
     const build = await Bun.build({
       entrypoints: [tmpFile],
       define,
+      target: "bun",
       minify: { syntax: true, whitespace: false },
     });
     if (!build.success) {
@@ -229,7 +230,7 @@ $$capture_start$$(${fn.async ? "async " : ""}${
     if (build.outputs.length !== 1) {
       throw new Error("expected one output");
     }
-    const output = await build.outputs[0].text();
+    let output = (await build.outputs[0].text()).replaceAll("// @bun\n", "");
     let usesDebug = output.includes("$debug_log");
     let usesAssert = output.includes("$assert");
     const captured = output.match(/\$\$capture_start\$\$([\s\S]+)\.\$\$capture_end\$\$/)![1];
diff --git a/src/codegen/bundle-modules.ts b/src/codegen/bundle-modules.ts
index aaa86834d467fb..9a1d91d25a1baa 100644
--- a/src/codegen/bundle-modules.ts
+++ b/src/codegen/bundle-modules.ts
@@ -117,7 +117,7 @@ for (let i = 0; i < moduleList.length; i++) {
 ${importStatements.join("\n")}
 
 ${processed.result.slice(1).trim()}
-$$EXPORT$$(__intrinsic__exports).$$EXPORT_END$$;
+;$$EXPORT$$(__intrinsic__exports).$$EXPORT_END$$;
 `;
 
     // Attempt to optimize "$exports = ..." to a variableless return
diff --git a/src/codegen/generate-classes.ts b/src/codegen/generate-classes.ts
index 10c705c219bd18..12c78ff158470f 100644
--- a/src/codegen/generate-classes.ts
+++ b/src/codegen/generate-classes.ts
@@ -294,7 +294,7 @@ function propRow(
     return `{ "${name}"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute${extraPropertyAttributes}), NoIntrinsic, { HashTableValue::GetterSetterType, ${getter}, 0 } }
 `.trim();
   } else if (getter && !supportsObjectCreate && writable) {
-    return `{ "${name}"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute${extraPropertyAttributes}), NoIntrinsic, { HashTableValue::GetterSetterType, ${getter}, ${setter} } } 
+    return `{ "${name}"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute${extraPropertyAttributes}), NoIntrinsic, { HashTableValue::GetterSetterType, ${getter}, ${setter} } }
 `.trim();
   } else if (getter && supportsObjectCreate) {
     setter = getter.replace("Get", "Set");
@@ -356,14 +356,14 @@ function generatePrototype(typeName, obj) {
 
   if (obj.construct) {
     externs += `
-extern JSC_CALLCONV void* JSC_HOST_CALL_ATTRIBUTES ${classSymbolName(typeName, "construct")}(JSC::JSGlobalObject*, JSC::CallFrame*); 
+extern JSC_CALLCONV void* JSC_HOST_CALL_ATTRIBUTES ${classSymbolName(typeName, "construct")}(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(js${typeName}Constructor);
 `;
   }
 
   if (obj.wantsThis) {
     externs += `
-extern JSC_CALLCONV void* JSC_HOST_CALL_ATTRIBUTES ${classSymbolName(typeName, "_setThis")}(JSC::JSGlobalObject*, void*, JSC::EncodedJSValue); 
+extern JSC_CALLCONV void* JSC_HOST_CALL_ATTRIBUTES ${classSymbolName(typeName, "_setThis")}(JSC::JSGlobalObject*, void*, JSC::EncodedJSValue);
 `;
   }
 
@@ -809,11 +809,11 @@ function renderCallbacksZig(typeName, callbacks: Record<string, string>) {
   out += "\n};\n";
 
   out += `
-  
+
   pub fn callbacks(_: *const ${typeName}, instance: JSC.JSValue) Callbacks {
     return .{.instance = instance };
   }
-  
+
 `;
 
   return "\n" + out;
@@ -1027,10 +1027,10 @@ JSC_DEFINE_CUSTOM_GETTER(${symbolName(typeName, name)}GetterWrap, (JSGlobalObjec
     }
 
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-    
+
     if (JSValue cachedValue = thisObject->${cacheName}.get())
         return JSValue::encode(cachedValue);
-    
+
     JSC::JSValue result = JSC::JSValue::decode(
         ${symbolName(typeName, proto[name].getter)}(thisObject->wrapped(),${
           proto[name].this!! ? " thisValue, " : ""
@@ -1523,7 +1523,7 @@ extern JSC_CALLCONV void* JSC_HOST_CALL_ATTRIBUTES ${typeName}__fromJSDirect(JSC
 
   Zig::GlobalObject* globalObject = jsDynamicCast<Zig::GlobalObject*>(object->globalObject());
 
-  if (UNLIKELY(globalObject == nullptr || cell->structureID() != globalObject->${className(typeName)}Structure()->id())) { 
+  if (UNLIKELY(globalObject == nullptr || cell->structureID() != globalObject->${className(typeName)}Structure()->id())) {
     return nullptr;
   }
 
@@ -1691,8 +1691,8 @@ function generateZig(
   function renderMethods() {
     const exports = new Map();
     var output = `
-const JavaScriptCoreBindings = struct {    
-    
+const JavaScriptCoreBindings = struct {
+
 `;
 
     if (estimatedSize) {
@@ -1726,9 +1726,15 @@ const JavaScriptCoreBindings = struct {
     if (construct && !noConstructor) {
       exports.set("construct", classSymbolName(typeName, "construct"));
       output += `
-        pub fn ${classSymbolName(typeName, "construct")}(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) ?*${typeName} {
+        pub fn ${classSymbolName(typeName, "construct")}(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) ?*anyopaque {
           if (comptime Environment.enable_logs) zig("<r><blue>new<r> ${typeName}<d>({})<r>", .{callFrame});
-          return @call(.always_inline, ${typeName}.constructor, .{globalObject, callFrame});
+          return @as(*${typeName}, ${typeName}.constructor(globalObject, callFrame) catch |err| switch (err) {
+            error.JSError => return null,
+            error.OutOfMemory => {
+              globalObject.throwOutOfMemory();
+              return null;
+            },
+          });
         }
       `;
     }
@@ -1748,7 +1754,10 @@ const JavaScriptCoreBindings = struct {
       output += `
         pub fn ${classSymbolName(typeName, "call")}(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
           if (comptime Environment.enable_logs) zig("${typeName}<d>({})<r>", .{callFrame});
-          return @call(.always_inline, ${typeName}.call, .{globalObject, callFrame});
+          return @call(.always_inline, ${typeName}.call, .{globalObject, callFrame}) catch |err| switch (err) {
+            error.JSError => .zero,
+            error.OutOfMemory => globalObject.throwOutOfMemoryValue(),
+          };
         }
       `;
     }
@@ -1801,7 +1810,10 @@ const JavaScriptCoreBindings = struct {
           output += `
         pub fn ${names.fn}(thisValue: *${typeName}, globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame${proto[name].passThis ? ", js_this_value: JSC.JSValue" : ""}) callconv(JSC.conv) JSC.JSValue {
           if (comptime Environment.enable_logs) zig("<d>${typeName}.<r>${name}<d>({})<r>", .{callFrame});
-          return @call(.always_inline, ${typeName}.${fn}, .{thisValue, globalObject, callFrame${proto[name].passThis ? ", js_this_value" : ""}});
+          return @call(.always_inline, ${typeName}.${fn}, .{thisValue, globalObject, callFrame${proto[name].passThis ? ", js_this_value" : ""}}) catch |err| switch (err) {
+            error.JSError => .zero,
+            error.OutOfMemory => globalObject.throwOutOfMemoryValue(),
+          };
         }
         `;
         }
@@ -1848,7 +1860,10 @@ const JavaScriptCoreBindings = struct {
           output += `
         pub fn ${names.fn}(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
           if (comptime Environment.enable_logs) JSC.markBinding(@src());
-          return @call(.always_inline, ${typeName}.${fn}, .{globalObject, callFrame});
+          return @call(.always_inline, ${typeName}.${fn}, .{globalObject, callFrame}) catch |err| switch (err) {
+            error.JSError => .zero,
+            error.OutOfMemory => globalObject.throwOutOfMemoryValue(),
+          };
         }
         `;
         }
@@ -2138,6 +2153,13 @@ const Environment = bun.Environment;
 const std = @import("std");
 const zig = bun.Output.scoped(.zig, true);
 
+const wrapHostFunction = bun.gen_classes_lib.wrapHostFunction;
+const wrapMethod = bun.gen_classes_lib.wrapMethod;
+const wrapMethodWithThis = bun.gen_classes_lib.wrapMethodWithThis;
+const wrapConstructor = bun.gen_classes_lib.wrapConstructor;
+const wrapGetterCallback = bun.gen_classes_lib.wrapGetterCallback;
+const wrapGetterWithValueCallback = bun.gen_classes_lib.wrapGetterWithValueCallback;
+
 pub const StaticGetterType = fn(*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue) callconv(JSC.conv) JSC.JSValue;
 pub const StaticSetterType = fn(*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue, JSC.JSValue) callconv(JSC.conv) bool;
 pub const StaticCallbackType = JSC.JSHostFunctionType;
diff --git a/src/codegen/generate-js2native.ts b/src/codegen/generate-js2native.ts
index 1d9ffee55ce4a7..e3b3c06c33b374 100644
--- a/src/codegen/generate-js2native.ts
+++ b/src/codegen/generate-js2native.ts
@@ -18,7 +18,7 @@ interface NativeCall {
 interface WrapperCall {
   type: NativeCallType;
   wrap_kind: "new-function";
-  symbol_taget: string;
+  symbol_target: string;
   symbol_generated: string;
   display_name: string;
   call_length: number;
@@ -91,7 +91,7 @@ export function registerNativeCall(
     wrapperCalls.push({
       type: call_type,
       wrap_kind: "new-function",
-      symbol_taget: symbol,
+      symbol_target: symbol,
       symbol_generated: "js2native_wrap_" + symbol.replace(/[^A-Za-z]/g, "_"),
       display_name: callBaseName(symbol),
       call_length: create_fn_len,
@@ -135,7 +135,7 @@ export function getJS2NativeCPP() {
       call => (
         externs.push(`extern "C" SYSV_ABI JSC::EncodedJSValue ${symbol(call)}_workaround(Zig::GlobalObject*);` + "\n"),
         [
-          `JSC::JSValue ${symbol(call)}(Zig::GlobalObject* global) {`,
+          `static ALWAYS_INLINE JSC::JSValue ${symbol(call)}(Zig::GlobalObject* global) {`,
           `  return JSValue::decode(${symbol(call)}_workaround(global));`,
           `}` + "\n\n",
         ]
@@ -149,14 +149,20 @@ export function getJS2NativeCPP() {
           externs.push(
             `BUN_DECLARE_HOST_FUNCTION(${symbol({
               type: "zig",
-              symbol: x.symbol_taget,
+              symbol: x.symbol_target,
+              filename: x.filename,
             })});`,
           ),
         "") || "",
-        `JSC::JSValue ${x.symbol_generated}(Zig::GlobalObject* globalObject) {`,
+        `static ALWAYS_INLINE JSC::JSValue ${x.symbol_generated}(Zig::GlobalObject* globalObject) {`,
         `  return JSC::JSFunction::create(globalObject->vm(), globalObject, ${x.call_length}, ${JSON.stringify(
           x.display_name,
-        )}_s, ${symbol({ type: x.type, symbol: x.symbol_taget })}, JSC::ImplementationVisibility::Public);`,
+        )}_s, ${symbol({
+          type: x.type,
+          symbol: x.symbol_target,
+
+          filename: x.filename,
+        })}, JSC::ImplementationVisibility::Public);`,
         `}`,
       ].join("\n");
     }
@@ -175,11 +181,15 @@ export function getJS2NativeCPP() {
     ...nativeCallStrings,
     ...wrapperCallStrings,
     `typedef JSC::JSValue (*JS2NativeFunction)(Zig::GlobalObject*);`,
-    `static JS2NativeFunction js2nativePointers[] = {`,
-    ...nativeCalls.map(x => `  ${cppPointer(x)},`),
-    `};`,
-    `};`,
+    `static ALWAYS_INLINE JSC::JSValue callJS2Native(int32_t index, Zig::GlobalObject* global) {`,
+    ` switch(index) {`,
+    ...nativeCalls.map(x => `    case ${x.id}: return ${symbol(x)}(global);`),
+    `    default:`,
+    `      __builtin_unreachable();`,
+    `  }`,
+    `}`,
     `#define JS2NATIVE_COUNT ${nativeCalls.length}`,
+    "}",
   ].join("\n");
 }
 
@@ -191,9 +201,9 @@ export function getJS2NativeZig(gs2NativeZigPath: string) {
       .filter(x => x.type === "zig")
       .flatMap(call => [
         `export fn ${symbol(call)}_workaround(global: *JSC.JSGlobalObject) callconv(JSC.conv) JSC.JSValue {`,
-        `  return @import(${JSON.stringify(path.relative(path.dirname(gs2NativeZigPath), call.filename))}).${
+        `  return global.errorUnionToCPP(@import(${JSON.stringify(path.relative(path.dirname(gs2NativeZigPath), call.filename))}).${
           call.symbol
-        }(global);`,
+        }(global));`,
         "}",
       ]),
     ...wrapperCalls
@@ -201,19 +211,17 @@ export function getJS2NativeZig(gs2NativeZigPath: string) {
       .flatMap(x => [
         `export fn ${symbol({
           type: "zig",
-          symbol: x.symbol_taget,
+          symbol: x.symbol_target,
+          filename: x.filename,
         })}(global: *JSC.JSGlobalObject, call_frame: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {`,
         `
           const function = @import(${JSON.stringify(path.relative(path.dirname(gs2NativeZigPath), x.filename))});
-          return @call(.always_inline, function.${x.symbol_taget}, .{global, call_frame});`,
+          return @call(.always_inline, function.${x.symbol_target}, .{global, call_frame}) catch |err| switch (err) {
+              error.JSError => .zero,
+              error.OutOfMemory => global.throwOutOfMemoryValue(),
+          };`,
         "}",
       ]),
-    "comptime {",
-    ...nativeCalls.filter(x => x.type === "zig").flatMap(call => `  _ = &${symbol(call)}_workaround;`),
-    ...wrapperCalls
-      .filter(x => x.type === "zig")
-      .flatMap(x => `  _ = &${symbol({ type: "zig", symbol: x.symbol_taget })};`),
-    "}",
   ].join("\n");
 }
 
diff --git a/src/codegen/replacements.ts b/src/codegen/replacements.ts
index ec09c14289f1cd..025f0f854d126c 100644
--- a/src/codegen/replacements.ts
+++ b/src/codegen/replacements.ts
@@ -140,7 +140,11 @@ export interface ReplacementRule {
   global?: boolean;
 }
 
-export const function_replacements = ["$debug", "$assert", "$zig", "$newZigFunction", "$cpp", "$newCppFunction"];
+export const function_replacements = [
+  "$debug", "$assert", "$zig", "$newZigFunction", "$cpp", "$newCppFunction",
+  "$isPromiseResolved",
+];
+const function_regexp = new RegExp(`__intrinsic__(${function_replacements.join("|").replaceAll('$', '')})`);
 
 /** Applies source code replacements as defined in `replacements` */
 export function applyReplacements(src: string, length: number) {
@@ -152,7 +156,7 @@ export function applyReplacements(src: string, length: number) {
   }
   let match;
   if (
-    (match = slice.match(/__intrinsic__(debug|assert|zig|cpp|newZigFunction|newCppFunction)$/)) &&
+    (match = slice.match(function_regexp)) &&
     rest.startsWith("(")
   ) {
     const name = match[1];
@@ -222,6 +226,18 @@ export function applyReplacements(src: string, length: number) {
       const id = registerNativeCall(kind, args[0], args[1], is_create_fn ? args[2] : undefined);
 
       return [slice.slice(0, match.index) + "__intrinsic__lazy(" + id + ")", inner.rest, true];
+    } else if (name === "isPromiseResolved") {
+      const inner = sliceSourceCode(rest, true);
+      let args;
+      if (debug) {
+        // use a property on @lazy as a temporary holder for the expression. only in debug!
+        args = `($assert(__intrinsic__isPromise(__intrinsic__lazy.temp=${inner.result.slice(0, -1)}))),(__intrinsic__getPromiseInternalField(__intrinsic__lazy.temp, __intrinsic__promiseFieldFlags) & __intrinsic__promiseStateMask) === (__intrinsic__lazy.temp = undefined, __intrinsic__promiseStateFulfilled))`;
+      } else {
+        args = `((__intrinsic__getPromiseInternalField(${inner.result.slice(0,-1)}), __intrinsic__promiseFieldFlags) & __intrinsic__promiseStateMask) === __intrinsic__promiseStateFulfilled)`;
+      }
+      return [slice.slice(0, match.index) + args, inner.rest, true];
+    } else {
+      throw new Error("Unknown preprocessor macro " + name);
     }
   }
   return [slice, rest, false];
diff --git a/src/compile_target.zig b/src/compile_target.zig
index 242a36c09e0935..cf0f0acc202f5f 100644
--- a/src/compile_target.zig
+++ b/src/compile_target.zig
@@ -19,7 +19,7 @@ version: bun.Semver.Version = .{
     .minor = @truncate(Environment.version.minor),
     .patch = @truncate(Environment.version.patch),
 },
-libc: Libc = .default,
+libc: Libc = if (!Environment.isMusl) .default else .musl,
 
 const Libc = enum {
     /// The default libc for the target
diff --git a/src/comptime_string_map.zig b/src/comptime_string_map.zig
index 754c1a5d547476..f5cecafc37eed0 100644
--- a/src/comptime_string_map.zig
+++ b/src/comptime_string_map.zig
@@ -173,7 +173,8 @@ pub fn ComptimeStringMapWithKeyType(comptime KeyType: type, comptime V: type, co
                 }
             }
 
-            const str = bun.String.tryFromJS(input, globalThis) orelse return null;
+            const str = bun.String.fromJS(input, globalThis);
+            bun.assert(str.tag != .Dead);
             defer str.deref();
             return getWithEql(str, bun.String.eqlComptime);
         }
@@ -186,7 +187,8 @@ pub fn ComptimeStringMapWithKeyType(comptime KeyType: type, comptime V: type, co
                 }
             }
 
-            const str = bun.String.tryFromJS(input, globalThis) orelse return null;
+            const str = bun.String.fromJS(input, globalThis);
+            bun.assert(str.tag != .Dead);
             defer str.deref();
             return str.inMapCaseInsensitive(@This());
         }
diff --git a/src/crash_handler.zig b/src/crash_handler.zig
index 34ba5eb1829c9a..d9cb08f9899240 100644
--- a/src/crash_handler.zig
+++ b/src/crash_handler.zig
@@ -59,6 +59,9 @@ threadlocal var panic_stage: usize = 0;
 /// rate or only crash due to assertion failures, are debug-only. See `Action`.
 pub threadlocal var current_action: ?Action = null;
 
+var before_crash_handlers: std.ArrayListUnmanaged(struct { *anyopaque, *const OnBeforeCrash }) = .{};
+var before_crash_handlers_mutex: std.Thread.Mutex = .{};
+
 const CPUFeatures = @import("./bun.js/bindings/CPUFeatures.zig").CPUFeatures;
 
 /// This structure and formatter must be kept in sync with `bun.report`'s decoder implementation.
@@ -180,6 +183,13 @@ pub fn crashHandler(
             panic_stage = 1;
             _ = panicking.fetchAdd(1, .seq_cst);
 
+            if (before_crash_handlers_mutex.tryLock()) {
+                for (before_crash_handlers.items) |item| {
+                    const ptr, const cb = item;
+                    cb(ptr);
+                }
+            }
+
             {
                 panic_mutex.lock();
                 defer panic_mutex.unlock();
@@ -1669,7 +1679,7 @@ pub const js_bindings = struct {
         return obj;
     }
 
-    pub fn jsGetMachOImageZeroOffset(_: *bun.JSC.JSGlobalObject, _: *bun.JSC.CallFrame) JSValue {
+    pub fn jsGetMachOImageZeroOffset(_: *bun.JSC.JSGlobalObject, _: *bun.JSC.CallFrame) bun.JSError!JSValue {
         if (!bun.Environment.isMac) return .undefined;
 
         const header = std.c._dyld_get_image_header(0) orelse return .undefined;
@@ -1679,7 +1689,7 @@ pub const js_bindings = struct {
         return JSValue.jsNumber(base_address - vmaddr_slide);
     }
 
-    pub fn jsSegfault(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsSegfault(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         @setRuntimeSafety(false);
         const ptr: [*]align(1) u64 = @ptrFromInt(0xDEADBEEF);
         ptr[0] = 0xDEADBEEF;
@@ -1687,23 +1697,23 @@ pub const js_bindings = struct {
         return .undefined;
     }
 
-    pub fn jsPanic(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsPanic(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         bun.crash_handler.panicImpl("invoked crashByPanic() handler", null, null);
     }
 
-    pub fn jsRootError(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsRootError(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         bun.crash_handler.handleRootError(error.Test, null);
     }
 
-    pub fn jsOutOfMemory(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsOutOfMemory(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         bun.outOfMemory();
     }
 
-    pub fn jsRaiseIgnoringPanicHandler(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsRaiseIgnoringPanicHandler(_: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         bun.Global.raiseIgnoringPanicHandler(.SIGSEGV);
     }
 
-    pub fn jsGetFeaturesAsVLQ(global: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsGetFeaturesAsVLQ(global: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const bits = bun.Analytics.packedFeatures();
         var buf = std.BoundedArray(u8, 16){};
         writeU64AsTwoVLQs(buf.writer(), @bitCast(bits)) catch {
@@ -1714,7 +1724,7 @@ pub const js_bindings = struct {
         return str.transferToJS(global);
     }
 
-    pub fn jsGetFeatureData(global: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn jsGetFeatureData(global: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const obj = JSValue.createEmptyObject(global, 5);
         const list = bun.Analytics.packed_features_list;
         const array = JSValue.createEmptyArray(global, list.len);
@@ -1733,3 +1743,32 @@ pub const js_bindings = struct {
         return obj;
     }
 };
+
+const OnBeforeCrash = fn (opaque_ptr: *anyopaque) void;
+
+/// For large codebases such as bun.bake.DevServer, it may be helpful
+/// to dump a large amount of state to a file to aid debugging a crash.
+///
+/// Pre-crash handlers are likely, but not guaranteed to call. Errors are ignored.
+pub fn appendPreCrashHandler(comptime T: type, ptr: *T, comptime handler: fn (*T) anyerror!void) !void {
+    const wrap = struct {
+        fn onCrash(opaque_ptr: *anyopaque) void {
+            handler(@ptrCast(@alignCast(opaque_ptr))) catch |err| {
+                bun.handleErrorReturnTrace(err, @errorReturnTrace());
+            };
+        }
+    };
+
+    before_crash_handlers_mutex.lock();
+    defer before_crash_handlers_mutex.unlock();
+    try before_crash_handlers.append(bun.default_allocator, .{ ptr, wrap.onCrash });
+}
+
+pub fn removePreCrashHandler(ptr: *anyopaque) void {
+    before_crash_handlers_mutex.lock();
+    defer before_crash_handlers_mutex.unlock();
+    const index = for (before_crash_handlers.items, 0..) |item, i| {
+        if (item.@"0" == ptr) break i;
+    } else return;
+    _ = before_crash_handlers.orderedRemove(index);
+}
diff --git a/src/css/css_internals.zig b/src/css/css_internals.zig
index be61eb545eebcc..9b664c306864f0 100644
--- a/src/css/css_internals.zig
+++ b/src/css/css_internals.zig
@@ -17,19 +17,19 @@ const TestKind = enum {
     prefix,
 };
 
-pub fn minifyTestWithOptions(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn minifyTestWithOptions(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     return testingImpl(globalThis, callframe, .minify);
 }
 
-pub fn prefixTestWithOptions(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn prefixTestWithOptions(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     return testingImpl(globalThis, callframe, .prefix);
 }
 
-pub fn testWithOptions(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn testWithOptions(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     return testingImpl(globalThis, callframe, .normal);
 }
 
-pub fn testingImpl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame, comptime test_kind: TestKind) JSC.JSValue {
+pub fn testingImpl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame, comptime test_kind: TestKind) bun.JSError!JSC.JSValue {
     var arena = arena_ orelse brk: {
         break :brk Arena.init() catch @panic("oopsie arena no good");
     };
@@ -94,7 +94,7 @@ pub fn testingImpl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame, c
             var minify_options: bun.css.MinifyOptions = bun.css.MinifyOptions.default();
             if (options_arg) |optarg| {
                 if (optarg.isObject()) {
-                    minify_options.targets.browsers = targetsFromJS(globalThis, optarg);
+                    minify_options.targets.browsers = try targetsFromJS(globalThis, optarg);
                 }
             }
             _ = stylesheet.minify(alloc, minify_options).assert();
@@ -125,66 +125,66 @@ pub fn testingImpl(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame, c
     }
 }
 
-fn targetsFromJS(globalThis: *JSC.JSGlobalObject, jsobj: JSValue) bun.css.targets.Browsers {
+fn targetsFromJS(globalThis: *JSC.JSGlobalObject, jsobj: JSValue) bun.JSError!bun.css.targets.Browsers {
     var targets = bun.css.targets.Browsers{};
 
-    if (jsobj.getTruthy(globalThis, "android")) |val| {
+    if (try jsobj.getTruthy(globalThis, "android")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.android = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "chrome")) |val| {
+    if (try jsobj.getTruthy(globalThis, "chrome")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.chrome = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "edge")) |val| {
+    if (try jsobj.getTruthy(globalThis, "edge")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.edge = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "firefox")) |val| {
+    if (try jsobj.getTruthy(globalThis, "firefox")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.firefox = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "ie")) |val| {
+    if (try jsobj.getTruthy(globalThis, "ie")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.ie = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "ios_saf")) |val| {
+    if (try jsobj.getTruthy(globalThis, "ios_saf")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.ios_saf = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "opera")) |val| {
+    if (try jsobj.getTruthy(globalThis, "opera")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.opera = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "safari")) |val| {
+    if (try jsobj.getTruthy(globalThis, "safari")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.safari = @intFromFloat(value);
             }
         }
     }
-    if (jsobj.getTruthy(globalThis, "samsung")) |val| {
+    if (try jsobj.getTruthy(globalThis, "samsung")) |val| {
         if (val.isInt32()) {
             if (val.getNumber()) |value| {
                 targets.samsung = @intFromFloat(value);
@@ -195,7 +195,7 @@ fn targetsFromJS(globalThis: *JSC.JSGlobalObject, jsobj: JSValue) bun.css.target
     return targets;
 }
 
-pub fn attrTest(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn attrTest(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     var arena = arena_ orelse brk: {
         break :brk Arena.init() catch @panic("oopsie arena no good");
     };
@@ -239,7 +239,7 @@ pub fn attrTest(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.
     var targets: bun.css.targets.Targets = .{};
     if (arguments.nextEat()) |arg| {
         if (arg.isObject()) {
-            targets.browsers = targetsFromJS(globalThis, arg);
+            targets.browsers = try targetsFromJS(globalThis, arg);
         }
     }
 
diff --git a/src/css/values/color_js.zig b/src/css/values/color_js.zig
index 4db9f5e6b8f0ce..b9689745bf95ad 100644
--- a/src/css/values/color_js.zig
+++ b/src/css/values/color_js.zig
@@ -147,8 +147,8 @@ pub const Ansi256 = struct {
     }
 };
 
-pub fn jsFunctionColor(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
-    const args = callFrame.argumentsUndef(2).all();
+pub fn jsFunctionColor(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+    const args = callFrame.argumentsAsArray(2);
     if (args[0].isUndefined()) {
         globalThis.throwInvalidArgumentType("color", "input", "string, number, or object");
         return JSC.JSValue.jsUndefined();
@@ -169,7 +169,7 @@ pub fn jsFunctionColor(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFram
                 return JSC.JSValue.jsUndefined();
             }
 
-            break :brk args[1].toEnum(globalThis, "format", OutputColorFormat) catch return .zero;
+            break :brk try args[1].toEnum(globalThis, "format", OutputColorFormat);
         }
 
         break :brk OutputColorFormat.css;
@@ -248,7 +248,7 @@ pub fn jsFunctionColor(globalThis: *JSC.JSGlobalObject, callFrame: *JSC.CallFram
                 return .zero;
             }
 
-            const a: ?u8 = if (args[0].getTruthy(globalThis, "a")) |a_value| brk2: {
+            const a: ?u8 = if (try args[0].getTruthy(globalThis, "a")) |a_value| brk2: {
                 if (a_value.isNumber()) {
                     break :brk2 @intCast(@mod(@as(i64, @intFromFloat(a_value.asNumber() * 255.0)), 256));
                 }
diff --git a/src/defines.zig b/src/defines.zig
index 60bfe3df950c96..f038248505ab35 100644
--- a/src/defines.zig
+++ b/src/defines.zig
@@ -66,6 +66,13 @@ pub const DefineData = struct {
         };
     }
 
+    pub fn initStaticString(str: *const js_ast.E.String) DefineData {
+        return .{
+            .value = .{ .e_string = @constCast(str) },
+            .can_be_removed_if_unused = true,
+        };
+    }
+
     pub fn merge(a: DefineData, b: DefineData) DefineData {
         return DefineData{
             .value = b.value,
diff --git a/src/deps/c_ares.zig b/src/deps/c_ares.zig
index b51dbbd6acd3e7..074574eda396de 100644
--- a/src/deps/c_ares.zig
+++ b/src/deps/c_ares.zig
@@ -1554,13 +1554,16 @@ pub const ares_uri_reply = struct_ares_uri_reply;
 pub const ares_addr_node = struct_ares_addr_node;
 pub const ares_addr_port_node = struct_ares_addr_port_node;
 
-pub export fn Bun__canonicalizeIP(
-    ctx: *JSC.JSGlobalObject,
+comptime {
+    const Bun__canonicalizeIP = JSC.toJSHostFunction(Bun__canonicalizeIP_);
+    @export(Bun__canonicalizeIP, .{ .name = "Bun__canonicalizeIP" });
+}
+pub fn Bun__canonicalizeIP_(
+    globalThis: *JSC.JSGlobalObject,
     callframe: *JSC.CallFrame,
-) callconv(JSC.conv) JSC.JSValue {
+) bun.JSError!JSC.JSValue {
     JSC.markBinding(@src());
 
-    const globalThis = ctx.ptr();
     const arguments = callframe.arguments(1);
 
     if (arguments.len == 0) {
@@ -1655,9 +1658,4 @@ pub fn getSockaddr(addr: []const u8, port: u16, sa: *std.posix.sockaddr) c_int {
     return -1;
 }
 
-comptime {
-    if (!JSC.is_bindgen) {
-        _ = Bun__canonicalizeIP;
-    }
-}
 const GetAddrInfo = bun.dns.GetAddrInfo;
diff --git a/src/deps/uws.zig b/src/deps/uws.zig
index 5cd40f8eb648f1..68cdf62a80219c 100644
--- a/src/deps/uws.zig
+++ b/src/deps/uws.zig
@@ -219,7 +219,7 @@ pub const UpgradedDuplex = struct {
     fn onReceivedData(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         log("onReceivedData", .{});
 
         const function = callframe.callee();
@@ -269,7 +269,7 @@ pub const UpgradedDuplex = struct {
     fn onWritable(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         log("onWritable", .{});
 
         _ = globalObject;
@@ -291,7 +291,7 @@ pub const UpgradedDuplex = struct {
     fn onCloseJS(
         globalObject: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         log("onCloseJS", .{});
 
         _ = globalObject;
@@ -2640,12 +2640,36 @@ pub const create_bun_socket_error_t = enum(i32) {
     load_ca_file,
     invalid_ca_file,
     invalid_ca,
+
+    pub fn toJS(this: create_bun_socket_error_t, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        return switch (this) {
+            .none => brk: {
+                bun.debugAssert(false);
+                break :brk .null;
+            },
+            .load_ca_file => globalObject.ERR_BORINGSSL("Failed to load CA file", .{}).toJS(),
+            .invalid_ca_file => globalObject.ERR_BORINGSSL("Invalid CA file", .{}).toJS(),
+            .invalid_ca => globalObject.ERR_BORINGSSL("Invalid CA", .{}).toJS(),
+        };
+    }
 };
 
 pub const us_bun_verify_error_t = extern struct {
     error_no: i32 = 0,
     code: [*c]const u8 = null,
     reason: [*c]const u8 = null,
+
+    pub fn toJS(this: *const us_bun_verify_error_t, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        const code = if (this.code == null) "" else this.code[0..bun.len(this.code)];
+        const reason = if (this.reason == null) "" else this.reason[0..bun.len(this.reason)];
+
+        const fallback = JSC.SystemError{
+            .code = bun.String.createUTF8(code),
+            .message = bun.String.createUTF8(reason),
+        };
+
+        return fallback.toErrorInstance(globalObject);
+    }
 };
 pub extern fn us_ssl_socket_verify_error_from_ssl(ssl: *BoringSSL.SSL) us_bun_verify_error_t;
 
@@ -3540,7 +3564,7 @@ pub fn NewApp(comptime ssl: bool) type {
         pub fn constructorFailed(app: *ThisApp) bool {
             return uws_constructor_failed(ssl_flag, app);
         }
-        pub fn num_subscribers(app: *ThisApp, topic: []const u8) c_uint {
+        pub fn numSubscribers(app: *ThisApp, topic: []const u8) u32 {
             return uws_num_subscribers(ssl_flag, @as(*uws_app_t, @ptrCast(app)), topic.ptr, topic.len);
         }
         pub fn publish(app: *ThisApp, topic: []const u8, message: []const u8, opcode: Opcode, compress: bool) bool {
@@ -4521,3 +4545,5 @@ pub fn onThreadExit() void {
 }
 
 extern fn uws_app_clear_routes(ssl_flag: c_int, app: *uws_app_t) void;
+
+pub extern fn us_socket_upgrade_to_tls(s: *Socket, new_context: *SocketContext, sni: ?[*:0]const u8) ?*Socket;
diff --git a/src/fd.zig b/src/fd.zig
index 3bab075c3a6b08..b1d466b0019e1c 100644
--- a/src/fd.zig
+++ b/src/fd.zig
@@ -242,7 +242,7 @@ pub const FDImpl = packed struct {
                 const fd = this.encode();
                 bun.assert(fd != bun.invalid_fd);
                 bun.assert(fd.cast() >= 0);
-                break :result switch (bun.C.getErrno(bun.sys.system.close(fd.cast()))) {
+                break :result switch (bun.C.getErrno(bun.sys.syscall.close(fd.cast()))) {
                     .BADF => bun.sys.Error{ .errno = @intFromEnum(posix.E.BADF), .syscall = .close, .fd = fd },
                     else => null,
                 };
@@ -251,7 +251,7 @@ pub const FDImpl = packed struct {
                 const fd = this.encode();
                 bun.assert(fd != bun.invalid_fd);
                 bun.assert(fd.cast() >= 0);
-                break :result switch (bun.C.getErrno(bun.sys.system.@"close$NOCANCEL"(fd.cast()))) {
+                break :result switch (bun.C.getErrno(bun.sys.syscall.@"close$NOCANCEL"(fd.cast()))) {
                     .BADF => bun.sys.Error{ .errno = @intFromEnum(posix.E.BADF), .syscall = .close, .fd = fd },
                     else => null,
                 };
@@ -320,12 +320,10 @@ pub const FDImpl = packed struct {
 
     // If a non-number is given, returns null.
     // If the given number is not an fd (negative), an error is thrown and error.JSException is returned.
-    pub fn fromJSValidated(value: JSValue, global: *JSC.JSGlobalObject, exception_ref: JSC.C.ExceptionRef) !?FDImpl {
+    pub fn fromJSValidated(value: JSValue, global: *JSC.JSGlobalObject) bun.JSError!?FDImpl {
         if (!value.isAnyInt()) return null;
         const fd64 = value.toInt64();
-        if (!JSC.Node.Valid.fileDescriptor(fd64, global, exception_ref)) {
-            return error.JSException;
-        }
+        try JSC.Node.Valid.fileDescriptor(fd64, global);
         const fd: i32 = @intCast(fd64);
 
         if (comptime env.isWindows) {
diff --git a/src/feature_flags.zig b/src/feature_flags.zig
index eecfa45a163885..6ca2c08fb62c7c 100644
--- a/src/feature_flags.zig
+++ b/src/feature_flags.zig
@@ -13,9 +13,6 @@ pub const jsx_runtime_is_cjs = true;
 
 pub const tracing = true;
 
-/// Disabled due to bugs
-pub const minify_javascript_string_length = false;
-
 // TODO: remove this flag, it should use bun.Output.scoped
 pub const verbose_watcher = false;
 
@@ -161,6 +158,9 @@ pub fn isLibdeflateEnabled() bool {
 /// Enable Bun Kit's experimental bundler tools
 pub const bake = env.is_canary or env.isDebug;
 
+/// Additional debugging features for Bake, such as the incremental visualizer.
+pub const bake_debugging_features = bake and (env.is_canary or env.isDebug);
+
 /// Enable --server-components
 pub const cli_server_components = bake;
 
diff --git a/src/fmt.zig b/src/fmt.zig
index 309a278c8a523b..436a8575616e3c 100644
--- a/src/fmt.zig
+++ b/src/fmt.zig
@@ -1714,10 +1714,10 @@ pub const fmt_js_test_bindings = struct {
     };
 
     /// Internal function for testing in highlighter.test.ts
-    pub fn jsFunctionStringFormatter(globalThis: *bun.JSC.JSGlobalObject, callframe: *bun.JSC.CallFrame) callconv(bun.JSC.conv) bun.JSC.JSValue {
+    pub fn jsFunctionStringFormatter(globalThis: *bun.JSC.JSGlobalObject, callframe: *bun.JSC.CallFrame) bun.JSError!bun.JSC.JSValue {
         const args = callframe.arguments(2);
         if (args.len < 2) {
-            globalThis.throwNotEnoughArguments("code", 1, 0);
+            return globalThis.throwNotEnoughArguments("code", 1, 0);
         }
 
         const code = args.ptr[0].toSliceOrNull(globalThis) orelse
diff --git a/src/fs.zig b/src/fs.zig
index d14c3f676a60fc..4eeb342a8e4278 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -189,13 +189,13 @@ pub const FileSystem = struct {
                 const name = try strings.StringOrTinyString.initAppendIfNeeded(
                     name_slice,
                     *FileSystem.FilenameStore,
-                    &FileSystem.FilenameStore.instance,
+                    FileSystem.FilenameStore.instance,
                 );
 
                 const name_lowercased = try strings.StringOrTinyString.initLowerCaseAppendIfNeeded(
                     name_slice,
                     *FileSystem.FilenameStore,
-                    &FileSystem.FilenameStore.instance,
+                    FileSystem.FilenameStore.instance,
                 );
 
                 break :brk EntryStore.instance.append(.{
diff --git a/src/gen_classes_lib.zig b/src/gen_classes_lib.zig
new file mode 100644
index 00000000000000..7533184fd5663b
--- /dev/null
+++ b/src/gen_classes_lib.zig
@@ -0,0 +1,52 @@
+/// Handwritten utility functions for ZigGeneratedClasses.zig
+const bun = @import("root").bun;
+const JSC = bun.JSC;
+const JSValue = JSC.JSValue;
+const JSGlobalObject = JSC.JSGlobalObject;
+
+pub const WrappedMethod = fn (*anyopaque, *JSGlobalObject, *JSC.CallFrame) callconv(JSC.conv) JSValue;
+pub const WrappedMethodWithThis = fn (*anyopaque, *JSGlobalObject, *JSC.CallFrame, JSValue) callconv(JSC.conv) JSValue;
+pub const WrappedConstructor = fn (*JSGlobalObject, *JSC.CallFrame) callconv(JSC.conv) ?*anyopaque;
+pub const WrappedClassGetterCallback = fn (*anyopaque, *JSGlobalObject) callconv(JSC.conv) JSValue;
+
+pub const wrapHostFunction = JSC.toJSHostFunction;
+
+pub fn wrapMethod(comptime T: type, comptime func: anytype) WrappedMethod {
+    return struct {
+        pub fn call(ptr: *anyopaque, global: *JSGlobalObject, call_frame: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+            return global.errorUnionToCPP(func(@as(*T, @alignCast(@ptrCast(ptr))), global, call_frame));
+        }
+    }.call;
+}
+
+pub fn wrapMethodWithThis(comptime T: type, comptime func: anytype) WrappedMethodWithThis {
+    return struct {
+        pub fn call(ptr: *anyopaque, global: *JSGlobalObject, call_frame: *JSC.CallFrame, this_value: JSValue) callconv(JSC.conv) JSValue {
+            return global.errorUnionToCPP(func(@as(*T, @alignCast(@ptrCast(ptr))), global, call_frame, this_value));
+        }
+    }.call;
+}
+
+pub fn wrapConstructor(comptime T: type, comptime func: anytype) WrappedConstructor {
+    return struct {
+        pub fn call(global: *JSGlobalObject, call_frame: *JSC.CallFrame) callconv(JSC.conv) ?*anyopaque {
+            return @as(?*T, global.errorUnionToCPP(func(global, call_frame)));
+        }
+    }.call;
+}
+
+pub fn wrapGetterCallback(comptime T: type, comptime func: anytype) WrappedClassGetterCallback {
+    return struct {
+        pub fn call(ptr: *anyopaque, global: *JSGlobalObject) callconv(JSC.conv) JSValue {
+            return func(@as(*T, @alignCast(@ptrCast(ptr))), global);
+        }
+    }.call;
+}
+
+pub fn wrapGetterWithValueCallback(comptime T: type, comptime func: anytype) WrappedClassGetterCallback {
+    return struct {
+        pub fn call(ptr: *anyopaque, global: *JSGlobalObject) callconv(JSC.conv) JSValue {
+            return func(@as(*T, @alignCast(@ptrCast(ptr))), global);
+        }
+    }.call;
+}
diff --git a/src/http/method.zig b/src/http/method.zig
index cba47679fba34b..67103c523e638a 100644
--- a/src/http/method.zig
+++ b/src/http/method.zig
@@ -54,16 +54,15 @@ pub const Method = enum {
         var values = std.enums.EnumSet(Method).initFull();
         values.remove(.HEAD);
         values.remove(.TRACE);
-        values.remove(.OPTIONS);
         break :brk values;
     };
 
     const with_request_body: std.enums.EnumSet(Method) = brk: {
         var values = std.enums.EnumSet(Method).initFull();
+        values.remove(.GET);
         values.remove(.HEAD);
-        values.remove(.TRACE);
         values.remove(.OPTIONS);
-        values.remove(.GET);
+        values.remove(.TRACE);
         break :brk values;
     };
 
diff --git a/src/ini.zig b/src/ini.zig
index 4db24c0b19e9a3..1046aa6cf18542 100644
--- a/src/ini.zig
+++ b/src/ini.zig
@@ -286,7 +286,7 @@ pub const Parser = struct {
                 const c = val[i];
                 if (esc) {
                     switch (c) {
-                        '\\' => try unesc.appendSlice(&[_]u8{ '\\', '\\' }),
+                        '\\' => try unesc.appendSlice(&[_]u8{'\\'}),
                         ';', '#', '$' => try unesc.append(c),
                         '.' => {
                             if (comptime usage == .section) {
@@ -512,7 +512,7 @@ pub const IniTestingAPIs = struct {
     pub fn loadNpmrcFromJS(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) callconv(.C) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arg = callframe.argument(0);
         const npmrc_contents = arg.toBunString(globalThis);
         defer npmrc_contents.deref();
@@ -536,15 +536,15 @@ pub const IniTestingAPIs = struct {
             }).init(globalThis, envjs);
             defer object_iter.deinit();
 
-            envmap.ensureTotalCapacity(object_iter.len) catch return globalThis.throwOutOfMemoryValue();
+            try envmap.ensureTotalCapacity(object_iter.len);
 
             while (object_iter.next()) |key| {
-                const keyslice = key.toOwnedSlice(allocator) catch return globalThis.throwOutOfMemoryValue();
+                const keyslice = try key.toOwnedSlice(allocator);
                 var value = object_iter.value;
                 if (value == .undefined) continue;
 
                 const value_str = value.getZigString(globalThis);
-                const slice = value_str.toOwnedSlice(allocator) catch return globalThis.throwOutOfMemoryValue();
+                const slice = try value_str.toOwnedSlice(allocator);
 
                 envmap.put(keyslice, .{
                     .value = slice,
@@ -552,29 +552,30 @@ pub const IniTestingAPIs = struct {
                 }) catch return globalThis.throwOutOfMemoryValue();
             }
 
-            const map = allocator.create(bun.DotEnv.Map) catch return globalThis.throwOutOfMemoryValue();
+            const map = try allocator.create(bun.DotEnv.Map);
             map.* = .{
                 .map = envmap,
             };
 
             const env = bun.DotEnv.Loader.init(map, allocator);
-            const envstable = allocator.create(bun.DotEnv.Loader) catch return globalThis.throwOutOfMemoryValue();
+            const envstable = try allocator.create(bun.DotEnv.Loader);
             envstable.* = env;
             break :brk envstable;
         };
 
-        const install = allocator.create(bun.Schema.Api.BunInstall) catch return globalThis.throwOutOfMemoryValue();
+        const install = try allocator.create(bun.Schema.Api.BunInstall);
         install.* = std.mem.zeroes(bun.Schema.Api.BunInstall);
         loadNpmrc(allocator, install, env, ".npmrc", &log, &source) catch {
             return log.toJS(globalThis, allocator, "error");
         };
 
-        var obj = JSC.JSValue.createEmptyObject(globalThis, 3);
-        obj.protect();
-        defer obj.unprotect();
-
         const default_registry_url, const default_registry_token, const default_registry_username, const default_registry_password = brk: {
-            const default_registry = install.default_registry orelse break :brk .{ bun.String.static(Registry.default_url[0..]), bun.String.empty, bun.String.empty, bun.String.empty };
+            const default_registry = install.default_registry orelse break :brk .{
+                bun.String.static(Registry.default_url[0..]),
+                bun.String.empty,
+                bun.String.empty,
+                bun.String.empty,
+            };
 
             break :brk .{
                 bun.String.fromBytes(default_registry.url),
@@ -590,34 +591,15 @@ pub const IniTestingAPIs = struct {
             default_registry_password.deref();
         }
 
-        obj.put(
-            globalThis,
-            bun.String.static("default_registry_url"),
-            default_registry_url.toJS(globalThis),
-        );
-        obj.put(
-            globalThis,
-            bun.String.static("default_registry_token"),
-            default_registry_token.toJS(globalThis),
-        );
-        obj.put(
-            globalThis,
-            bun.String.static("default_registry_username"),
-            default_registry_username.toJS(globalThis),
-        );
-        obj.put(
-            globalThis,
-            bun.String.static("default_registry_password"),
-            default_registry_password.toJS(globalThis),
-        );
-
-        return obj;
+        return globalThis.createObjectFromStruct(.{
+            .default_registry_url = default_registry_url.toJS(globalThis),
+            .default_registry_token = default_registry_token.toJS(globalThis),
+            .default_registry_username = default_registry_username.toJS(globalThis),
+            .default_registry_password = default_registry_password.toJS(globalThis),
+        }).toJS();
     }
 
-    pub fn parse(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) callconv(.C) JSC.JSValue {
+    pub fn parse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments_ = callframe.arguments(1);
         const arguments = arguments_.slice();
 
@@ -630,13 +612,9 @@ pub const IniTestingAPIs = struct {
         var parser = Parser.init(bun.default_allocator, "<src>", utf8str.slice(), globalThis.bunVM().bundler.env);
         defer parser.deinit();
 
-        parser.parse(parser.arena.allocator()) catch |err| {
-            switch (err) {
-                error.OutOfMemory => return globalThis.throwOutOfMemoryValue(),
-            }
-        };
+        try parser.parse(parser.arena.allocator());
 
-        return parser.out.toJS(bun.default_allocator, globalThis, .{ .decode_escape_sequences = true }) catch |e| {
+        return parser.out.toJS(bun.default_allocator, globalThis) catch |e| {
             globalThis.throwError(e, "failed to turn AST into JS");
             return .undefined;
         };
@@ -660,7 +638,6 @@ pub const ToStringFormatter = struct {
             .e_number => try writer.print("{d}", .{this.d.e_number.value}),
             .e_string => try writer.print("{s}", .{this.d.e_string.data}),
             .e_null => try writer.print("null", .{}),
-            .e_utf8_string => try writer.print("{s}", .{this.d.e_utf8_string.data}),
 
             else => |tag| if (bun.Environment.isDebug) {
                 Output.panic("Unexpected AST node: {s}", .{@tagName(tag)});
diff --git a/src/install/dependency.zig b/src/install/dependency.zig
index 6a1bd3a9618652..66959bd4937c4a 100644
--- a/src/install/dependency.zig
+++ b/src/install/dependency.zig
@@ -308,7 +308,7 @@ pub const Version = struct {
     literal: String = .{},
     value: Value = .{ .uninitialized = {} },
 
-    pub fn toJS(dep: *const Version, buf: []const u8, globalThis: *JSC.JSGlobalObject) JSC.JSValue {
+    pub fn toJS(dep: *const Version, buf: []const u8, globalThis: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue {
         const object = JSC.JSValue.createEmptyObject(globalThis, 2);
         object.put(globalThis, "type", bun.String.static(@tagName(dep.tag)).toJS(globalThis));
 
@@ -332,15 +332,8 @@ pub const Version = struct {
             },
             .npm => {
                 object.put(globalThis, "name", dep.value.npm.name.toJS(buf, globalThis));
-                var version_str = bun.String.createFormat("{}", .{dep.value.npm.version.fmt(buf)}) catch {
-                    globalThis.throwOutOfMemory();
-                    return .zero;
-                };
-                object.put(
-                    globalThis,
-                    "version",
-                    version_str.transferToJS(globalThis),
-                );
+                var version_str = try bun.String.createFormat("{}", .{dep.value.npm.version.fmt(buf)});
+                object.put(globalThis, "version", version_str.transferToJS(globalThis));
                 object.put(globalThis, "alias", JSC.JSValue.jsBoolean(dep.value.npm.is_alias));
             },
             .symlink => {
@@ -362,7 +355,7 @@ pub const Version = struct {
             },
             else => {
                 globalThis.throwTODO("Unsupported dependency type");
-                return .zero;
+                return error.JSError;
             },
         }
 
@@ -763,7 +756,7 @@ pub const Version = struct {
             return .npm;
         }
 
-        pub fn inferFromJS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+        pub fn inferFromJS(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
             const arguments = callframe.arguments(1).slice();
             if (arguments.len == 0 or !arguments[0].isString()) {
                 return .undefined;
@@ -946,7 +939,7 @@ pub fn parseWithTag(
             };
 
             if (is_alias) {
-                PackageManager.instance.known_npm_aliases.put(
+                PackageManager.get().known_npm_aliases.put(
                     allocator,
                     alias_hash.?,
                     result,
@@ -1234,10 +1227,10 @@ pub fn parseWithTag(
     }
 }
 
-pub fn fromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+pub fn fromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
     const arguments = callframe.arguments(2).slice();
     if (arguments.len == 1) {
-        return bun.install.PackageManager.UpdateRequest.fromJS(globalThis, arguments[0]);
+        return try bun.install.PackageManager.UpdateRequest.fromJS(globalThis, arguments[0]);
     }
     var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
     defer arena.deinit();
@@ -1277,16 +1270,14 @@ pub fn fromJS(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JS
 
     const dep: Version = Dependency.parse(allocator, SlicedString.init(buf, alias).value(), null, buf, &sliced, &log) orelse {
         if (log.msgs.items.len > 0) {
-            globalThis.throwValue(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependency"));
-            return .zero;
+            return globalThis.throwValue2(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependency"));
         }
 
         return .undefined;
     };
 
     if (log.msgs.items.len > 0) {
-        globalThis.throwValue(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependency"));
-        return .zero;
+        return globalThis.throwValue2(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependency"));
     }
     log.deinit();
 
diff --git a/src/install/extract_tarball.zig b/src/install/extract_tarball.zig
index d3bf173b93314d..8ca72a1fc85472 100644
--- a/src/install/extract_tarball.zig
+++ b/src/install/extract_tarball.zig
@@ -475,7 +475,7 @@ fn extract(this: *const ExtractTarball, tgz_bytes: []const u8) !Install.ExtractD
     };
     defer final_dir.close();
     // and get the fd path
-    const final_path = bun.getFdPath(
+    const final_path = bun.getFdPathZ(
         final_dir.fd,
         &final_path_buf,
     ) catch |err| {
@@ -538,18 +538,36 @@ fn extract(this: *const ExtractTarball, tgz_bytes: []const u8) !Install.ExtractD
 
     // create an index storing each version of a package installed
     if (strings.indexOfChar(basename, '/') == null) create_index: {
-        var index_dir = bun.MakePath.makeOpenPath(cache_dir, name, .{}) catch break :create_index;
-        defer index_dir.close();
-        index_dir.symLink(
-            final_path,
-            switch (this.resolution.tag) {
-                .github => folder_name["@GH@".len..],
-                // trim "name@" from the prefix
-                .npm => folder_name[name.len + 1 ..],
-                else => folder_name,
-            },
-            .{ .is_directory = true },
-        ) catch break :create_index;
+        const dest_name = switch (this.resolution.tag) {
+            .github => folder_name["@GH@".len..],
+            // trim "name@" from the prefix
+            .npm => folder_name[name.len + 1 ..],
+            else => folder_name,
+        };
+
+        if (comptime Environment.isWindows) {
+            bun.MakePath.makePath(u8, cache_dir, name) catch {
+                break :create_index;
+            };
+
+            var dest_buf: bun.PathBuffer = undefined;
+            const dest_path = bun.path.joinAbsStringBufZ(
+                // only set once, should be fine to read not on main thread
+                this.package_manager.cache_directory_path,
+                &dest_buf,
+                &[_]string{ name, dest_name },
+                .windows,
+            );
+
+            bun.sys.sys_uv.symlinkUV(final_path, dest_path, bun.windows.libuv.UV_FS_SYMLINK_JUNCTION).unwrap() catch {
+                break :create_index;
+            };
+        } else {
+            var index_dir = bun.MakePath.makeOpenPath(cache_dir, name, .{}) catch break :create_index;
+            defer index_dir.close();
+
+            bun.sys.symlinkat(final_path, bun.toFD(index_dir), dest_name).unwrap() catch break :create_index;
+        }
     }
 
     const ret_json_path = try FileSystem.instance.dirname_store.append(@TypeOf(json_path), json_path);
diff --git a/src/install/install.zig b/src/install/install.zig
index 3fbb8f010f44b3..eae919c75d1826 100644
--- a/src/install/install.zig
+++ b/src/install/install.zig
@@ -450,7 +450,7 @@ const NetworkTask = struct {
 
         this.callback = .{
             .package_manifest = .{
-                .name = try strings.StringOrTinyString.initAppendIfNeeded(name, *FileSystem.FilenameStore, &FileSystem.FilenameStore.instance),
+                .name = try strings.StringOrTinyString.initAppendIfNeeded(name, *FileSystem.FilenameStore, FileSystem.FilenameStore.instance),
                 .loaded_manifest = if (loaded_manifest) |manifest| manifest.* else null,
             },
         };
@@ -1755,7 +1755,7 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
             var queue: Queue = undefined;
             pub fn getQueue() *Queue {
                 queue = Queue{
-                    .thread_pool = &PackageManager.instance.thread_pool,
+                    .thread_pool = &PackageManager.get().thread_pool,
                 };
                 return &queue;
             }
@@ -2142,8 +2142,8 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
                             var unintall_task: *@This() = @fieldParentPtr("task", task);
                             var debug_timer = bun.Output.DebugTimer.start();
                             defer {
-                                _ = PackageManager.instance.decrementPendingTasks();
-                                PackageManager.instance.wake();
+                                _ = PackageManager.get().decrementPendingTasks();
+                                PackageManager.get().wake();
                             }
 
                             defer unintall_task.deinit();
@@ -2183,21 +2183,20 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
                     var task = UninstallTask.new(.{
                         .absolute_path = bun.default_allocator.dupeZ(u8, bun.path.joinAbsString(FileSystem.instance.top_level_dir, &.{ this.node_modules.path.items, temp_path }, .auto)) catch bun.outOfMemory(),
                     });
-                    PackageManager.instance.thread_pool.schedule(bun.ThreadPool.Batch.from(&task.task));
-                    _ = PackageManager.instance.incrementPendingTasks(1);
+                    PackageManager.get().thread_pool.schedule(bun.ThreadPool.Batch.from(&task.task));
+                    _ = PackageManager.get().incrementPendingTasks(1);
                 },
             }
         }
 
         pub fn isDanglingSymlink(path: [:0]const u8) bool {
             if (comptime Environment.isLinux) {
-                const rc = Syscall.system.open(path, .{ .PATH = true }, @as(u32, 0));
-                switch (Syscall.getErrno(rc)) {
-                    .SUCCESS => {
-                        _ = bun.sys.close(bun.toFD(@as(i32, @intCast(rc))));
+                switch (Syscall.open(path, bun.O.PATH, @as(u32, 0))) {
+                    .err => return true,
+                    .result => |fd| {
+                        _ = bun.sys.close(fd);
                         return false;
                     },
-                    else => return true,
                 }
             } else if (comptime Environment.isWindows) {
                 switch (bun.sys.sys_uv.open(path, 0, 0)) {
@@ -2210,13 +2209,12 @@ pub fn NewPackageInstall(comptime kind: PkgInstallKind) type {
                     },
                 }
             } else {
-                const rc = Syscall.system.open(path, .{}, .{});
-                switch (Syscall.getErrno(rc)) {
-                    .SUCCESS => {
-                        _ = Syscall.system.close(rc);
+                switch (Syscall.open(path, bun.O.PATH, @as(u32, 0))) {
+                    .err => return true,
+                    .result => |fd| {
+                        _ = bun.sys.close(fd);
                         return false;
                     },
-                    else => return true,
                 }
             }
         }
@@ -2511,8 +2509,8 @@ const TaskCallbackContext = union(enum) {
 const TaskCallbackList = std.ArrayListUnmanaged(TaskCallbackContext);
 const TaskDependencyQueue = std.HashMapUnmanaged(u64, TaskCallbackList, IdentityContext(u64), 80);
 
-const PreallocatedTaskStore = bun.HiveArray(Task, 512).Fallback;
-const PreallocatedNetworkTasks = bun.HiveArray(NetworkTask, 1024).Fallback;
+const PreallocatedTaskStore = bun.HiveArray(Task, 64).Fallback;
+const PreallocatedNetworkTasks = bun.HiveArray(NetworkTask, 128).Fallback;
 const ResolveTaskQueue = bun.UnboundedQueue(Task, .next);
 
 const ThreadPool = bun.ThreadPool;
@@ -2569,14 +2567,14 @@ const PackageManifestMap = struct {
             return null;
         }
 
-        if (PackageManager.instance.options.enable.manifest_cache) {
+        if (PackageManager.get().options.enable.manifest_cache) {
             if (Npm.PackageManifest.Serializer.loadByFileID(
-                PackageManager.instance.allocator,
+                PackageManager.get().allocator,
                 scope,
-                PackageManager.instance.getCacheDirectory(),
+                PackageManager.get().getCacheDirectory(),
                 name_hash,
             ) catch null) |manifest| {
-                if (PackageManager.instance.options.enable.manifest_cache_control and manifest.pkg.public_max_age > PackageManager.instance.timestamp_for_manifest_cache_control) {
+                if (PackageManager.get().options.enable.manifest_cache_control and manifest.pkg.public_max_age > PackageManager.get().timestamp_for_manifest_cache_control) {
                     entry.value_ptr.* = .{ .manifest = manifest };
                     return &entry.value_ptr.manifest;
                 } else {
@@ -2780,7 +2778,6 @@ pub const PackageManager = struct {
 
         pub const GetJSONOptions = struct {
             init_reset_store: bool = true,
-            always_decode_escape_sequences: bool = true,
             guess_indentation: bool = false,
         };
 
@@ -2840,7 +2837,6 @@ pub const PackageManager = struct {
                     .is_json = true,
                     .allow_comments = true,
                     .allow_trailing_commas = true,
-                    .always_decode_escape_sequences = opts.always_decode_escape_sequences,
                     .guess_indentation = opts.guess_indentation,
                 },
             ) catch |err| {
@@ -2894,7 +2890,6 @@ pub const PackageManager = struct {
                     .is_json = true,
                     .allow_comments = true,
                     .allow_trailing_commas = true,
-                    .always_decode_escape_sequences = opts.always_decode_escape_sequences,
                     .guess_indentation = opts.guess_indentation,
                 },
             );
@@ -2978,7 +2973,7 @@ pub const PackageManager = struct {
     };
 
     pub fn hasEnoughTimePassedBetweenWaitingMessages() bool {
-        const iter = instance.event_loop.loop().iterationNumber();
+        const iter = get().event_loop.loop().iterationNumber();
         if (TimePasser.last_time < iter) {
             TimePasser.last_time = iter;
             return true;
@@ -3179,7 +3174,7 @@ pub const PackageManager = struct {
                                     err: ?anyerror = null,
                                     manager: *PackageManager,
                                     pub fn isDone(closure: *@This()) bool {
-                                        var manager = closure.manager;
+                                        const manager = closure.manager;
                                         if (manager.pendingTaskCount() > 0) {
                                             manager.runTasks(
                                                 void,
@@ -3198,7 +3193,7 @@ pub const PackageManager = struct {
                                             };
 
                                             if (PackageManager.verbose_install and manager.pendingTaskCount() > 0) {
-                                                if (PackageManager.hasEnoughTimePassedBetweenWaitingMessages()) Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{PackageManager.instance.pendingTaskCount()});
+                                                if (PackageManager.hasEnoughTimePassedBetweenWaitingMessages()) Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{PackageManager.get().pendingTaskCount()});
                                             }
                                         }
 
@@ -3659,7 +3654,15 @@ pub const PackageManager = struct {
         try this.env.map.putAllocKeyAndValue(this.allocator, "BUN_WHICH_IGNORE_CWD", node_gyp_abs_dir);
     }
 
-    pub var instance: PackageManager = undefined;
+    const Holder = struct {
+        pub var ptr: *PackageManager = undefined;
+    };
+    pub fn allocatePackageManager() void {
+        Holder.ptr = bun.default_allocator.create(PackageManager) catch bun.outOfMemory();
+    }
+    pub fn get() *PackageManager {
+        return Holder.ptr;
+    }
 
     pub fn getNetworkTask(this: *PackageManager) *NetworkTask {
         return this.preallocated_network_tasks.get();
@@ -3917,13 +3920,21 @@ pub const PackageManager = struct {
 
         cache_path_buf[package_name.len] = std.fs.path.sep;
 
-        return this.getCacheDirectory().readLink(
-            cache_path,
-            buf,
-        ) catch |err| {
+        const cache_dir = bun.toFD(this.getCacheDirectory());
+
+        if (comptime Environment.isWindows) {
+            var path_buf: bun.PathBuffer = undefined;
+            const joined = bun.path.joinAbsStringBufZ(this.cache_directory_path, &path_buf, &[_]string{cache_path}, .windows);
+            return bun.sys.readlink(joined, buf).unwrap() catch |err| {
+                _ = bun.sys.unlink(joined);
+                return err;
+            };
+        }
+
+        return bun.sys.readlinkat(cache_dir, cache_path, buf).unwrap() catch |err| {
             // if we run into an error, delete the symlink
             // so that we don't repeatedly try to read it
-            std.posix.unlinkat(this.getCacheDirectory().fd, cache_path, 0) catch {};
+            _ = bun.sys.unlinkat(cache_dir, cache_path);
             return err;
         };
     }
@@ -4338,11 +4349,11 @@ pub const PackageManager = struct {
         try network_task.forTarball(
             this.allocator,
             &.{
-                .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+                .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
                 .name = try strings.StringOrTinyString.initAppendIfNeeded(
                     this.lockfile.str(&package.name),
                     *FileSystem.FilenameStore,
-                    &FileSystem.FilenameStore.instance,
+                    FileSystem.FilenameStore.instance,
                 ),
                 .resolution = package.resolution,
                 .cache_dir = this.getCacheDirectory(),
@@ -4352,7 +4363,7 @@ pub const PackageManager = struct {
                 .url = try strings.StringOrTinyString.initAppendIfNeeded(
                     url,
                     *FileSystem.FilenameStore,
-                    &FileSystem.FilenameStore.instance,
+                    FileSystem.FilenameStore.instance,
                 ),
             },
             scope,
@@ -4751,7 +4762,7 @@ pub const PackageManager = struct {
     ) *ThreadPool.Task {
         var task = this.preallocated_resolve_tasks.get();
         task.* = Task{
-            .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+            .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.package_manifest,
             .request = .{
@@ -4773,7 +4784,7 @@ pub const PackageManager = struct {
     ) *ThreadPool.Task {
         var task = this.preallocated_resolve_tasks.get();
         task.* = Task{
-            .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+            .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.extract,
             .request = .{
@@ -4800,7 +4811,7 @@ pub const PackageManager = struct {
     ) *ThreadPool.Task {
         var task = this.preallocated_resolve_tasks.get();
         task.* = Task{
-            .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+            .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.git_clone,
             .request = .{
@@ -4808,12 +4819,12 @@ pub const PackageManager = struct {
                     .name = strings.StringOrTinyString.initAppendIfNeeded(
                         name,
                         *FileSystem.FilenameStore,
-                        &FileSystem.FilenameStore.instance,
+                        FileSystem.FilenameStore.instance,
                     ) catch unreachable,
                     .url = strings.StringOrTinyString.initAppendIfNeeded(
                         this.lockfile.str(&repository.repo),
                         *FileSystem.FilenameStore,
-                        &FileSystem.FilenameStore.instance,
+                        FileSystem.FilenameStore.instance,
                     ) catch unreachable,
                     .env = Repository.shared_env.get(this.allocator, this.env),
                 },
@@ -4848,7 +4859,7 @@ pub const PackageManager = struct {
     ) *ThreadPool.Task {
         var task = this.preallocated_resolve_tasks.get();
         task.* = Task{
-            .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+            .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.git_checkout,
             .request = .{
@@ -4859,17 +4870,17 @@ pub const PackageManager = struct {
                     .name = strings.StringOrTinyString.initAppendIfNeeded(
                         name,
                         *FileSystem.FilenameStore,
-                        &FileSystem.FilenameStore.instance,
+                        FileSystem.FilenameStore.instance,
                     ) catch unreachable,
                     .url = strings.StringOrTinyString.initAppendIfNeeded(
                         this.lockfile.str(&resolution.value.git.repo),
                         *FileSystem.FilenameStore,
-                        &FileSystem.FilenameStore.instance,
+                        FileSystem.FilenameStore.instance,
                     ) catch unreachable,
                     .resolved = strings.StringOrTinyString.initAppendIfNeeded(
                         resolved,
                         *FileSystem.FilenameStore,
-                        &FileSystem.FilenameStore.instance,
+                        FileSystem.FilenameStore.instance,
                     ) catch unreachable,
                     .env = Repository.shared_env.get(this.allocator, this.env),
                 },
@@ -4901,17 +4912,17 @@ pub const PackageManager = struct {
     ) *ThreadPool.Task {
         var task = this.preallocated_resolve_tasks.get();
         task.* = Task{
-            .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+            .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
             .log = logger.Log.init(this.allocator),
             .tag = Task.Tag.local_tarball,
             .request = .{
                 .local_tarball = .{
                     .tarball = .{
-                        .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+                        .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
                         .name = strings.StringOrTinyString.initAppendIfNeeded(
                             name,
                             *FileSystem.FilenameStore,
-                            &FileSystem.FilenameStore.instance,
+                            FileSystem.FilenameStore.instance,
                         ) catch unreachable,
                         .resolution = resolution,
                         .cache_dir = this.getCacheDirectory(),
@@ -4920,7 +4931,7 @@ pub const PackageManager = struct {
                         .url = strings.StringOrTinyString.initAppendIfNeeded(
                             path,
                             *FileSystem.FilenameStore,
-                            &FileSystem.FilenameStore.instance,
+                            FileSystem.FilenameStore.instance,
                         ) catch unreachable,
                     },
                 },
@@ -5279,7 +5290,7 @@ pub const PackageManager = struct {
 
                                     var network_task = this.getNetworkTask();
                                     network_task.* = .{
-                                        .package_manager = &PackageManager.instance, // https://github.com/ziglang/zig/issues/14005
+                                        .package_manager = PackageManager.get(), // https://github.com/ziglang/zig/issues/14005
                                         .callback = undefined,
                                         .task_id = task_id,
                                         .allocator = this.allocator,
@@ -8670,7 +8681,8 @@ pub const PackageManager = struct {
 
         workspace_names.map.deinit();
 
-        var manager = &instance;
+        PackageManager.allocatePackageManager();
+        const manager = PackageManager.get();
         // var progress = Progress{};
         // var node = progress.start(name: []const u8, estimated_total_items: usize)
         manager.* = PackageManager{
@@ -8799,8 +8811,8 @@ pub const PackageManager = struct {
         }
 
         const cpu_count = bun.getThreadCount();
-
-        var manager = &instance;
+        PackageManager.allocatePackageManager();
+        const manager = PackageManager.get();
         var root_dir = try Fs.FileSystem.instance.fs.readDirectory(
             Fs.FileSystem.instance.top_level_dir,
             null,
@@ -9709,7 +9721,7 @@ pub const PackageManager = struct {
                     const outro_text =
                         \\<b>Examples:<r>
                         \\  <d>Display files that would be published, without publishing to the registry.<r>
-                        \\  <b><green>bun publish --dry-run<r>  
+                        \\  <b><green>bun publish --dry-run<r>
                         \\
                         \\  <d>Publish the current package with public access.<r>
                         \\  <b><green>bun publish --access public<r>
@@ -9989,7 +10001,7 @@ pub const PackageManager = struct {
                 lockfile.packages.items(.name)[this.package_id].slice(this.version_buf);
         }
 
-        pub fn fromJS(globalThis: *JSC.JSGlobalObject, input: JSC.JSValue) JSC.JSValue {
+        pub fn fromJS(globalThis: *JSC.JSGlobalObject, input: JSC.JSValue) bun.JSError!JSC.JSValue {
             var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
             defer arena.deinit();
             var stack = std.heap.stackFallback(1024, arena.allocator());
@@ -10025,25 +10037,22 @@ pub const PackageManager = struct {
             var array = Array{};
 
             const update_requests = parseWithError(allocator, &log, all_positionals.items, &array, .add, false) catch {
-                globalThis.throwValue(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependencies"));
-                return .zero;
+                return globalThis.throwValue2(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependencies"));
             };
             if (update_requests.len == 0) return .undefined;
 
             if (log.msgs.items.len > 0) {
-                globalThis.throwValue(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependencies"));
-                return .zero;
+                return globalThis.throwValue2(log.toJS(globalThis, bun.default_allocator, "Failed to parse dependencies"));
             }
 
             if (update_requests[0].failed) {
-                globalThis.throw("Failed to parse dependencies", .{});
-                return .zero;
+                return globalThis.throw2("Failed to parse dependencies", .{});
             }
 
             var object = JSC.JSValue.createEmptyObject(globalThis, 2);
             var name_str = bun.String.init(update_requests[0].name);
             object.put(globalThis, "name", name_str.transferToJS(globalThis));
-            object.put(globalThis, "version", update_requests[0].version.toJS(update_requests[0].version_buf, globalThis));
+            object.put(globalThis, "version", try update_requests[0].version.toJS(update_requests[0].version_buf, globalThis));
             return object;
         }
 
@@ -10412,7 +10421,6 @@ pub const PackageManager = struct {
             manager.log,
             manager.original_package_json_path,
             .{
-                .always_decode_escape_sequences = false,
                 .guess_indentation = true,
             },
         )) {
@@ -12337,7 +12345,7 @@ pub const PackageManager = struct {
                         if (PackageManager.hasEnoughTimePassedBetweenWaitingMessages()) Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} scripts\n", .{LifecycleScriptSubprocess.alive_count.load(.monotonic)});
                     }
 
-                    PackageManager.instance.sleep();
+                    PackageManager.get().sleep();
                 }
 
                 const optional = entry.optional;
@@ -12379,7 +12387,7 @@ pub const PackageManager = struct {
                     }
                 }
 
-                PackageManager.instance.sleep();
+                PackageManager.get().sleep();
             }
         }
 
@@ -13029,11 +13037,10 @@ pub const PackageManager = struct {
                                             resolution.fmt(this.lockfile.buffers.string_bytes.items, .posix),
                                         });
                                     }
+                                    const entry = this.summary.packages_with_blocked_scripts.getOrPut(this.manager.allocator, name_hash) catch bun.outOfMemory();
+                                    if (!entry.found_existing) entry.value_ptr.* = 0;
+                                    entry.value_ptr.* += count;
                                 }
-
-                                const entry = this.summary.packages_with_blocked_scripts.getOrPut(this.manager.allocator, name_hash) catch bun.outOfMemory();
-                                if (!entry.found_existing) entry.value_ptr.* = 0;
-                                entry.value_ptr.* += count;
                             },
                         }
 
@@ -13777,8 +13784,8 @@ pub const PackageManager = struct {
                             return true;
                         }
 
-                        if (PackageManager.verbose_install and PackageManager.instance.pendingTaskCount() > 0) {
-                            if (PackageManager.hasEnoughTimePassedBetweenWaitingMessages()) Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{PackageManager.instance.pendingTaskCount()});
+                        if (PackageManager.verbose_install and PackageManager.get().pendingTaskCount() > 0) {
+                            if (PackageManager.hasEnoughTimePassedBetweenWaitingMessages()) Output.prettyErrorln("<d>[PackageManager]<r> waiting for {d} tasks\n", .{PackageManager.get().pendingTaskCount()});
                         }
 
                         return closure.manager.pendingTaskCount() == 0 and closure.manager.hasNoMorePendingLifecycleScripts();
@@ -14917,7 +14924,7 @@ pub const bun_install_js_bindings = struct {
         return obj;
     }
 
-    pub fn jsParseLockfile(globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) JSValue {
+    pub fn jsParseLockfile(globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSValue {
         const allocator = bun.default_allocator;
         var log = logger.Log.init(allocator);
         defer log.deinit();
@@ -14930,9 +14937,12 @@ pub const bun_install_js_bindings = struct {
 
         var lockfile: Lockfile = undefined;
         lockfile.initEmpty(allocator);
+        if (globalObject.bunVM().bundler.resolver.env_loader == null) {
+            globalObject.bunVM().bundler.resolver.env_loader = globalObject.bunVM().bundler.env;
+        }
 
         // as long as we aren't migration from `package-lock.json`, leaving this undefined is okay
-        const manager = &PackageManager.instance;
+        const manager = globalObject.bunVM().bundler.resolver.getPackageManager();
 
         const load_result: Lockfile.LoadFromDiskResult = lockfile.loadFromDisk(manager, allocator, &log, lockfile_path, true);
 
diff --git a/src/install/lockfile.zig b/src/install/lockfile.zig
index 5648e2d5f17ce6..3d9b8681bfd174 100644
--- a/src/install/lockfile.zig
+++ b/src/install/lockfile.zig
@@ -1233,8 +1233,9 @@ pub const Printer = struct {
 
         var lockfile = try allocator.create(Lockfile);
 
+        PackageManager.allocatePackageManager();
         // TODO remove the need for manager when migrating from package-lock.json
-        const manager = &PackageManager.instance;
+        const manager = PackageManager.get();
 
         const load_from_disk = lockfile.loadFromDisk(manager, allocator, log, lockfile_path, false);
         switch (load_from_disk) {
@@ -1623,7 +1624,7 @@ pub const Printer = struct {
                 } else {
                     // just print installed packages for the current workspace
                     var workspace_package_id: DependencyID = 0;
-                    if (PackageManager.instance.workspace_name_hash) |workspace_name_hash| {
+                    if (PackageManager.get().workspace_name_hash) |workspace_name_hash| {
                         for (resolutions_list[0].begin()..resolutions_list[0].end()) |dep_id| {
                             const dep = dependencies_buffer[dep_id];
                             if (dep.behavior.isWorkspace() and dep.name_hash == workspace_name_hash) {
@@ -1729,7 +1730,7 @@ pub const Printer = struct {
 
                         {
                             const fmt = comptime Output.prettyFmt("<r> <d>- <r><b>{s}<r>\n", enable_ansi_colors);
-                            var manager = &bun.PackageManager.instance;
+                            const manager = PackageManager.get();
 
                             if (manager.track_installed_bin == .pending) {
                                 if (iterator.next() catch null) |bin_name| {
@@ -3846,7 +3847,7 @@ pub const Package = extern struct {
 
                                 var workspace = Package{};
 
-                                const json = PackageManager.instance.workspace_package_json_cache.getWithSource(bun.default_allocator, log, source, .{}).unwrap() catch break :brk false;
+                                const json = PackageManager.get().workspace_package_json_cache.getWithSource(bun.default_allocator, log, source, .{}).unwrap() catch break :brk false;
 
                                 try workspace.parseWithJSON(
                                     to_lockfile,
@@ -4793,7 +4794,7 @@ pub const Package = extern struct {
                         total_dependencies_count += try processWorkspaceNamesArray(
                             &workspace_names,
                             allocator,
-                            &PackageManager.instance.workspace_package_json_cache,
+                            &PackageManager.get().workspace_package_json_cache,
                             log,
                             arr,
                             &source,
@@ -4817,7 +4818,7 @@ pub const Package = extern struct {
                                     total_dependencies_count += try processWorkspaceNamesArray(
                                         &workspace_names,
                                         allocator,
-                                        &PackageManager.instance.workspace_package_json_cache,
+                                        &PackageManager.get().workspace_package_json_cache,
                                         log,
                                         packages_query.data.e_array,
                                         &source,
@@ -5709,7 +5710,7 @@ const Buffers = struct {
     ) !void {
         const buffers = lockfile.buffers;
         inline for (sizes.names) |name| {
-            if (PackageManager.instance.options.log_level.isVerbose()) {
+            if (PackageManager.get().options.log_level.isVerbose()) {
                 Output.prettyErrorln("Saving {d} {s}", .{ @field(buffers, name).items.len, name });
             }
 
@@ -5822,7 +5823,7 @@ const Buffers = struct {
             if (comptime Type == @TypeOf(this.dependencies)) {
                 external_dependency_list_ = try readArray(stream, allocator, std.ArrayListUnmanaged(Dependency.External));
 
-                if (PackageManager.instance.options.log_level.isVerbose()) {
+                if (PackageManager.get().options.log_level.isVerbose()) {
                     Output.prettyErrorln("Loaded {d} {s}", .{ external_dependency_list_.items.len, name });
                 }
             } else if (comptime Type == @TypeOf(this.trees)) {
@@ -5836,7 +5837,7 @@ const Buffers = struct {
                 }
             } else {
                 @field(this, name) = try readArray(stream, allocator, Type);
-                if (PackageManager.instance.options.log_level.isVerbose()) {
+                if (PackageManager.get().options.log_level.isVerbose()) {
                     Output.prettyErrorln("Loaded {d} {s}", .{ @field(this, name).items.len, name });
                 }
             }
diff --git a/src/install/npm.zig b/src/install/npm.zig
index 69f5bf6f0200ec..70aa24131ef66e 100644
--- a/src/install/npm.zig
+++ b/src/install/npm.zig
@@ -652,7 +652,7 @@ pub const OperatingSystem = enum(u16) {
     }
 
     const JSC = bun.JSC;
-    pub fn jsFunctionOperatingSystemIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn jsFunctionOperatingSystemIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const args = callframe.arguments(1);
         var operating_system = negatable(.none);
         var iter = args.ptr[0].arrayIterator(globalObject);
@@ -694,7 +694,7 @@ pub const Libc = enum(u8) {
     pub const current: Libc = @intFromEnum(glibc);
 
     const JSC = bun.JSC;
-    pub fn jsFunctionLibcIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn jsFunctionLibcIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const args = callframe.arguments(1);
         var libc = negatable(.none);
         var iter = args.ptr[0].arrayIterator(globalObject);
@@ -769,7 +769,7 @@ pub const Architecture = enum(u16) {
     }
 
     const JSC = bun.JSC;
-    pub fn jsFunctionArchitectureIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn jsFunctionArchitectureIsMatch(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const args = callframe.arguments(1);
         var architecture = negatable(.none);
         var iter = args.ptr[0].arrayIterator(globalObject);
@@ -1031,7 +1031,7 @@ pub const PackageManifest = struct {
             // This needs many more call sites, doesn't have much impact on this location.
             var realpath_buf: bun.PathBuffer = undefined;
             const path_to_use_for_opening_file = if (Environment.isWindows)
-                bun.path.joinAbsStringBufZ(PackageManager.instance.temp_dir_path, &realpath_buf, &.{ PackageManager.instance.temp_dir_path, tmp_path }, .auto)
+                bun.path.joinAbsStringBufZ(PackageManager.get().temp_dir_path, &realpath_buf, &.{ PackageManager.get().temp_dir_path, tmp_path }, .auto)
             else
                 tmp_path;
 
@@ -1084,7 +1084,7 @@ pub const PackageManifest = struct {
                 var did_close = false;
                 errdefer if (!did_close) file.close();
 
-                const cache_dir_abs = PackageManager.instance.cache_directory_path;
+                const cache_dir_abs = PackageManager.get().cache_directory_path;
                 const cache_path_abs = bun.path.joinAbsStringBufZ(cache_dir_abs, &realpath2_buf, &.{ cache_dir_abs, outpath }, .auto);
                 file.close();
                 did_close = true;
@@ -1172,7 +1172,7 @@ pub const PackageManifest = struct {
             });
 
             const batch = bun.ThreadPool.Batch.from(&task.task);
-            PackageManager.instance.thread_pool.schedule(batch);
+            PackageManager.get().thread_pool.schedule(batch);
         }
 
         fn manifestFileName(buf: []u8, file_id: u64, scope: *const Registry.Scope) ![:0]const u8 {
@@ -1283,7 +1283,7 @@ pub const PackageManifest = struct {
             return obj;
         }
 
-        pub fn jsParseManifest(global: *JSGlobalObject, callFrame: *CallFrame) JSValue {
+        pub fn jsParseManifest(global: *JSGlobalObject, callFrame: *CallFrame) bun.JSError!JSValue {
             const args = callFrame.arguments(2).slice();
             if (args.len < 2 or !args[0].isString() or !args[1].isString()) {
                 global.throw("expected manifest filename and registry string arguments", .{});
diff --git a/src/install/repository.zig b/src/install/repository.zig
index 2069d640c4502c..848731b7cbd6ee 100644
--- a/src/install/repository.zig
+++ b/src/install/repository.zig
@@ -423,7 +423,7 @@ pub const Repository = extern struct {
         });
 
         return if (cache_dir.openDirZ(folder_name, .{})) |dir| fetch: {
-            const path = Path.joinAbsString(PackageManager.instance.cache_directory_path, &.{folder_name}, .auto);
+            const path = Path.joinAbsString(PackageManager.get().cache_directory_path, &.{folder_name}, .auto);
 
             _ = exec(
                 allocator,
@@ -443,7 +443,7 @@ pub const Repository = extern struct {
         } else |not_found| clone: {
             if (not_found != error.FileNotFound) return not_found;
 
-            const target = Path.joinAbsString(PackageManager.instance.cache_directory_path, &.{folder_name}, .auto);
+            const target = Path.joinAbsString(PackageManager.get().cache_directory_path, &.{folder_name}, .auto);
 
             _ = exec(allocator, env, &[_]string{
                 "git",
@@ -479,7 +479,7 @@ pub const Repository = extern struct {
         committish: string,
         task_id: u64,
     ) !string {
-        const path = Path.joinAbsString(PackageManager.instance.cache_directory_path, &.{try std.fmt.bufPrint(&folder_name_buf, "{any}.git", .{
+        const path = Path.joinAbsString(PackageManager.get().cache_directory_path, &.{try std.fmt.bufPrint(&folder_name_buf, "{any}.git", .{
             bun.fmt.hexIntLower(task_id),
         })}, .auto);
 
@@ -520,7 +520,7 @@ pub const Repository = extern struct {
         var package_dir = bun.openDir(cache_dir, folder_name) catch |not_found| brk: {
             if (not_found != error.ENOENT) return not_found;
 
-            const target = Path.joinAbsString(PackageManager.instance.cache_directory_path, &.{folder_name}, .auto);
+            const target = Path.joinAbsString(PackageManager.get().cache_directory_path, &.{folder_name}, .auto);
 
             _ = exec(allocator, env, &[_]string{
                 "git",
@@ -541,7 +541,7 @@ pub const Repository = extern struct {
                 return err;
             };
 
-            const folder = Path.joinAbsString(PackageManager.instance.cache_directory_path, &.{folder_name}, .auto);
+            const folder = Path.joinAbsString(PackageManager.get().cache_directory_path, &.{folder_name}, .auto);
 
             _ = exec(allocator, env, &[_]string{ "git", "-C", folder, "checkout", "--quiet", resolved }) catch |err| {
                 log.addErrorFmt(
diff --git a/src/install/semver.zig b/src/install/semver.zig
index ef93a68be5f353..bac7bde18d17d0 100644
--- a/src/install/semver.zig
+++ b/src/install/semver.zig
@@ -2651,7 +2651,7 @@ pub const SemverObject = struct {
     pub fn order(
         globalThis: *JSC.JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
         defer arena.deinit();
         var stack_fallback = std.heap.stackFallback(512, arena.allocator());
@@ -2703,7 +2703,7 @@ pub const SemverObject = struct {
     pub fn satisfies(
         globalThis: *JSC.JSGlobalObject,
         callFrame: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         var arena = std.heap.ArenaAllocator.init(bun.default_allocator);
         defer arena.deinit();
         var stack_fallback = std.heap.stackFallback(512, arena.allocator());
diff --git a/src/js/builtins.d.ts b/src/js/builtins.d.ts
index 3e886899500512..2c07c8aa0e350d 100644
--- a/src/js/builtins.d.ts
+++ b/src/js/builtins.d.ts
@@ -15,6 +15,9 @@ declare function $debug(...args: any[]): void;
  */
 declare function $assert(check: any, ...message: any[]): asserts check;
 
+/** Asserts the input is a promise. Returns `true` if the promise is resolved */
+declare function $isPromiseResolved(promise: Promise<any>): boolean;
+
 declare const IS_BUN_DEVELOPMENT: boolean;
 
 /** Place this directly above a function declaration (like a decorator) to make it a getter. */
diff --git a/src/js/builtins/Bake.ts b/src/js/builtins/Bake.ts
index fa38f1d01278a6..47f9e8444486f3 100644
--- a/src/js/builtins/Bake.ts
+++ b/src/js/builtins/Bake.ts
@@ -2,33 +2,95 @@
 /// <reference path="../../bake/bake.d.ts" />
 import type { Bake } from "bun";
 
-type RenderStatic = Bake.ServerEntryPoint['staticRender'];
+type RenderStatic = Bake.ServerEntryPoint["prerender"];
+type TypeAndFlags = number;
+type FileIndex = number;
 
 /**
  * This layer is implemented in JavaScript to reduce Native <-> JS context switches,
  * as well as use the async primitives provided by the language.
  */
-export function renderRoutesForProd(
+export function renderRoutesForProdStatic(
   outBase: string,
-  renderStatic: RenderStatic,
-  clientEntryUrl: string,
-  files: string[],
+  allServerFiles: string[],
+  // Indexed by router type index
+  renderStatic: RenderStatic[],
+  clientEntryUrl: string[],
+  // Indexed by route index
   patterns: string[],
+  files: FileIndex[][],
+  typeAndFlags: TypeAndFlags[],
+  sourceRouteFiles: string[],
+  paramInformation: Array<null | string[]>,
   styles: string[][],
 ): Promise<void> {
-  const { join: pathJoin } = require('node:path');
+  $debug({
+    outBase,
+    allServerFiles,
+    renderStatic,
+    clientEntryUrl,
+    patterns,
+    files,
+    typeAndFlags,
+    sourceRouteFiles,
+    paramInformation,
+    styles,
+  });
+  const { join: pathJoin } = require("node:path");
 
-  return Promise.all(files.map(async(file, i) => {
-    const pattern = patterns[i];
-    const route = await import(file);
-    const results = await renderStatic(route, {
-      scripts: [clientEntryUrl],
-      styles: styles[i],
-    });
-    if (!results || typeof results !== 'object') {
-      // TODO: retrieve original filename
-      throw new Error(`Rendering route ${JSON.stringify(pattern)} did not return an object, got ${Bun.inspect(results)}`);
-    }
-    await Promise.all(Object.entries(results).map(([key, value]) => Bun.write(pathJoin(outBase, pattern + key), value)));
-  }));
-}
\ No newline at end of file
+  let loadedModules = new Array(allServerFiles.length);
+
+  return Promise.all(
+    files.map(async (fileList, i) => {
+      const typeAndFlag = typeAndFlags[i];
+      const type = typeAndFlag & 0xff;
+
+      var pageModule: any, layouts: any[];
+      $assert(fileList.length > 0);
+      if (fileList.length > 1) {
+        let anyPromise = false;
+        let loaded = fileList.map(
+          x => loadedModules[x] ?? ((anyPromise = true), import(allServerFiles[x]).then(x => (loadedModules[x] = x))),
+        );
+        [pageModule, ...layouts] = anyPromise ? await Promise.all(loaded) : loaded;
+      } else {
+        const id = fileList[0];
+        pageModule = loadedModules[id] ?? (loadedModules[id] = await import(allServerFiles[fileList[0]]));
+        layouts = [];
+      }
+
+      if (paramInformation[i] != null) {
+        throw new Error("TODO: call the framework to get the param information");
+      }
+
+      // Call the framework's rendering function
+      const callback = renderStatic[type];
+      $assert(callback != null && $isCallable(callback));
+      const results = await callback({
+        scripts: [clientEntryUrl[type]],
+        modulepreload: [],
+        styles: styles[i],
+        layouts,
+        pageModule,
+        params: null,
+      } satisfies Bake.RouteMetadata);
+      if (results == null) {
+        throw new Error(`Route ${JSON.stringify(sourceRouteFiles[i])} cannot be pre-rendered to a static page.`);
+      }
+      if (typeof results !== "object") {
+        throw new Error(
+          `Rendering route ${JSON.stringify(sourceRouteFiles[i])} did not return an object, got ${Bun.inspect(results)}. This is a bug in the framework.`,
+        );
+      }
+      const { files } = results;
+      if (files == null) {
+        throw new Error(`Route ${JSON.stringify(sourceRouteFiles[i])} cannot be pre-rendered to a static page.`);
+      }
+      await Promise.all(
+        Object.entries(files).map(([key, value]) => {
+          return Bun.write(pathJoin(outBase, patterns[i] + key), value);
+        }),
+      );
+    }),
+  );
+}
diff --git a/src/js/builtins/ReadableStreamInternals.ts b/src/js/builtins/ReadableStreamInternals.ts
index 72b42a2c76dc5c..f81b71d6bdcd1b 100644
--- a/src/js/builtins/ReadableStreamInternals.ts
+++ b/src/js/builtins/ReadableStreamInternals.ts
@@ -1719,10 +1719,7 @@ export function readableStreamFromAsyncIterator(target, fn) {
             return;
           }
 
-          if (
-            $isPromise(promise) &&
-            ($getPromiseInternalField(promise, $promiseFieldFlags) & $promiseStateMask) === $promiseStateFulfilled
-          ) {
+          if ($isPromise(promise) && $isPromiseResolved(promise)) {
             clearImmediate(immediateTask);
             ({ value, done } = $getPromiseInternalField(promise, $promiseFieldReactionsOrResult));
             $assert(!$isPromise(value), "Expected a value, not a promise");
diff --git a/src/js/bun/sql.ts b/src/js/bun/sql.ts
index 7c1c275b4431ae..f4f29f431f77f3 100644
--- a/src/js/bun/sql.ts
+++ b/src/js/bun/sql.ts
@@ -1,6 +1,19 @@
+const enum QueryStatus {
+  active = 1 << 1,
+  cancelled = 1 << 2,
+  error = 1 << 3,
+  executed = 1 << 4,
+}
 const cmds = ["", "INSERT", "DELETE", "UPDATE", "MERGE", "SELECT", "MOVE", "FETCH", "COPY"];
 
 const PublicArray = globalThis.Array;
+const enum SSLMode {
+  disable = 0,
+  prefer = 1,
+  require = 2,
+  verify_ca = 3,
+  verify_full = 4,
+}
 
 class SQLResultArray extends PublicArray {
   static [Symbol.toStringTag] = "SQLResults";
@@ -10,11 +23,6 @@ class SQLResultArray extends PublicArray {
   count;
 }
 
-const queryStatus_active = 1 << 1;
-const queryStatus_cancelled = 1 << 2;
-const queryStatus_error = 1 << 3;
-const queryStatus_executed = 1 << 4;
-
 const rawMode_values = 1;
 const rawMode_objects = 2;
 
@@ -33,6 +41,33 @@ const {
   init,
 } = $zig("postgres.zig", "createBinding");
 
+function normalizeSSLMode(value: string): SSLMode {
+  if (!value) {
+    return SSLMode.disable;
+  }
+
+  value = (value + "").toLowerCase();
+  switch (value) {
+    case "disable":
+      return SSLMode.disable;
+    case "prefer":
+      return SSLMode.prefer;
+    case "require":
+      return SSLMode.require;
+    case "verify-ca":
+    case "verify_ca":
+      return SSLMode.verify_ca;
+    case "verify-full":
+    case "verify_full":
+      return SSLMode.verify_full;
+    default: {
+      break;
+    }
+  }
+
+  throw $ERR_INVALID_ARG_VALUE(`Invalid SSL mode: ${value}`);
+}
+
 class Query extends PublicPromise {
   [_resolve];
   [_reject];
@@ -50,51 +85,51 @@ class Query extends PublicPromise {
     this[_reject] = reject_;
     this[_handle] = handle;
     this[_handler] = handler;
-    this[_queryStatus] = handle ? 0 : queryStatus_cancelled;
+    this[_queryStatus] = handle ? 0 : QueryStatus.cancelled;
   }
 
   async [_run]() {
     const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;
 
-    if (status & (queryStatus_executed | queryStatus_cancelled)) {
+    if (status & (QueryStatus.executed | QueryStatus.error | QueryStatus.cancelled)) {
       return;
     }
 
-    this[_queryStatus] |= queryStatus_executed;
+    this[_queryStatus] |= QueryStatus.executed;
     await 1;
     return handler(this, handle);
   }
 
   get active() {
-    return (this[_queryStatus] & queryStatus_active) !== 0;
+    return (this[_queryStatus] & QueryStatus.active) != 0;
   }
 
   set active(value) {
     const status = this[_queryStatus];
-    if (status & (queryStatus_cancelled | queryStatus_error)) {
+    if (status & (QueryStatus.cancelled | QueryStatus.error)) {
       return;
     }
 
     if (value) {
-      this[_queryStatus] |= queryStatus_active;
+      this[_queryStatus] |= QueryStatus.active;
     } else {
-      this[_queryStatus] &= ~queryStatus_active;
+      this[_queryStatus] &= ~QueryStatus.active;
     }
   }
 
   get cancelled() {
-    return (this[_queryStatus] & queryStatus_cancelled) !== 0;
+    return (this[_queryStatus] & QueryStatus.cancelled) !== 0;
   }
 
   resolve(x) {
-    this[_queryStatus] &= ~queryStatus_active;
+    this[_queryStatus] &= ~QueryStatus.active;
     this[_handle].done();
     return this[_resolve](x);
   }
 
   reject(x) {
-    this[_queryStatus] &= ~queryStatus_active;
-    this[_queryStatus] |= queryStatus_error;
+    this[_queryStatus] &= ~QueryStatus.active;
+    this[_queryStatus] |= QueryStatus.error;
     this[_handle].done();
 
     return this[_reject](x);
@@ -102,12 +137,12 @@ class Query extends PublicPromise {
 
   cancel() {
     var status = this[_queryStatus];
-    if (status & queryStatus_cancelled) {
+    if (status & QueryStatus.cancelled) {
       return this;
     }
-    this[_queryStatus] |= queryStatus_cancelled;
+    this[_queryStatus] |= QueryStatus.cancelled;
 
-    if (status & queryStatus_executed) {
+    if (status & QueryStatus.executed) {
       this[_handle].cancel();
     }
 
@@ -161,26 +196,27 @@ init(
 
     try {
       query.resolve(result);
-    } catch (e) {
-      console.log(e);
-    }
+    } catch (e) {}
   },
   function (query, reject) {
     try {
       query.reject(reject);
-    } catch (e) {
-      console.log(e);
-    }
+    } catch (e) {}
   },
 );
 
-function createConnection({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {
+function createConnection({ hostname, port, username, password, tls, query, database, sslMode }, onConnected, onClose) {
   return _createConnection(
     hostname,
     Number(port),
     username || "",
     password || "",
     database || "",
+    // > The default value for sslmode is prefer. As is shown in the table, this
+    // makes no sense from a security point of view, and it only promises
+    // performance overhead if possible. It is only provided as the default for
+    // backward compatibility, and is not recommended in secure deployments.
+    sslMode || SSLMode.disable,
     tls || null,
     query || "",
     onConnected,
@@ -188,7 +224,9 @@ function createConnection({ hostname, port, username, password, tls, query, data
   );
 }
 
-function normalizeStrings(strings) {
+var hasSQLArrayParameter = false;
+function normalizeStrings(strings, values) {
+  hasSQLArrayParameter = false;
   if ($isJSArray(strings)) {
     const count = strings.length;
     if (count === 0) {
@@ -196,9 +234,43 @@ function normalizeStrings(strings) {
     }
 
     var out = strings[0];
+
+    // For now, only support insert queries with array parameters
+    //
+    // insert into users ${sql(users)}
+    //
+    if (values.length > 0 && typeof values[0] === "object" && values[0] && values[0] instanceof SQLArrayParameter) {
+      if (values.length > 1) {
+        throw new Error("Cannot mix array parameters with other values");
+      }
+      hasSQLArrayParameter = true;
+      const { columns, value } = values[0];
+      const groupCount = value.length;
+      out += `values `;
+
+      let columnIndex = 1;
+      let columnCount = columns.length;
+      let lastColumnIndex = columnCount - 1;
+
+      for (var i = 0; i < groupCount; i++) {
+        out += i > 0 ? `, (` : `(`;
+
+        for (var j = 0; j < lastColumnIndex; j++) {
+          out += `$${columnIndex++}, `;
+        }
+
+        out += `$${columnIndex++})`;
+      }
+
+      for (var i = 1; i < count; i++) {
+        out += strings[i];
+      }
+
+      return out;
+    }
+
     for (var i = 1; i < count; i++) {
-      out += "$" + i;
-      out += strings[i];
+      out += `$${i}${strings[i]}`;
     }
     return out;
   }
@@ -206,12 +278,53 @@ function normalizeStrings(strings) {
   return strings + "";
 }
 
+class SQLArrayParameter {
+  value: any;
+  columns: string[];
+  constructor(value, keys) {
+    if (keys?.length === 0) {
+      keys = Object.keys(value[0]);
+    }
+
+    for (let key of keys) {
+      if (typeof key === "string") {
+        const asNumber = Number(key);
+        if (Number.isNaN(asNumber)) {
+          continue;
+        }
+        key = asNumber;
+      }
+
+      if (typeof key !== "string") {
+        if (Number.isSafeInteger(key)) {
+          if (key >= 0 && key <= 64 * 1024) {
+            continue;
+          }
+        }
+
+        throw new Error(`Invalid key: ${key}`);
+      }
+    }
+
+    this.value = value;
+    this.columns = keys;
+  }
+}
+
 function loadOptions(o) {
   var hostname, port, username, password, database, tls, url, query, adapter;
   const env = Bun.env;
+  var sslMode: SSLMode = SSLMode.disable;
 
   if (o === undefined || (typeof o === "string" && o.length === 0)) {
-    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;
+    let urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;
+    if (!urlString) {
+      urlString = env.TLS_POSTGRES_DATABASE_URL || env.TLS_DATABASE_URL;
+      if (urlString) {
+        sslMode = SSLMode.require;
+      }
+    }
+
     if (urlString) {
       url = new URL(urlString);
       o = {};
@@ -227,6 +340,11 @@ function loadOptions(o) {
         url = _url;
       }
     }
+
+    if (o?.tls) {
+      sslMode = SSLMode.require;
+      tls = o.tls;
+    }
   } else if (typeof o === "string") {
     url = new URL(o);
   }
@@ -236,18 +354,19 @@ function loadOptions(o) {
     if (adapter[adapter.length - 1] === ":") {
       adapter = adapter.slice(0, -1);
     }
+
     const queryObject = url.searchParams.toJSON();
     query = "";
     for (const key in queryObject) {
-      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;
+      if (key.toLowerCase() === "sslmode") {
+        sslMode = normalizeSSLMode(queryObject[key]);
+      } else {
+        query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;
+      }
     }
     query = query.trim();
   }
 
-  if (!o) {
-    o = {};
-  }
-
   hostname ||= o.hostname || o.host || env.PGHOST || "localhost";
   port ||= Number(o.port || env.PGPORT || 5432);
   username ||= o.username || o.user || env.PGUSERNAME || env.PGUSER || env.USER || env.USERNAME || "postgres";
@@ -256,6 +375,19 @@ function loadOptions(o) {
   tls ||= o.tls || o.ssl;
   adapter ||= o.adapter || "postgres";
 
+  if (sslMode !== SSLMode.disable && !tls?.serverName) {
+    if (hostname) {
+      tls = {
+        serverName: hostname,
+      };
+    } else {
+      tls = true;
+    }
+  }
+
+  if (!!tls) {
+    sslMode = SSLMode.prefer;
+  }
   port = Number(port);
 
   if (!Number.isSafeInteger(port) || port < 1 || port > 65535) {
@@ -266,7 +398,7 @@ function loadOptions(o) {
     throw new Error(`Unsupported adapter: ${adapter}. Only \"postgres\" is supported for now`);
   }
 
-  return { hostname, port, username, password, database, tls, query };
+  return { hostname, port, username, password, database, tls, query, sslMode };
 }
 
 function SQL(o) {
@@ -318,8 +450,21 @@ function SQL(o) {
     onConnected(err, undefined);
   }
 
+  function doCreateQuery(strings, values) {
+    const sqlString = normalizeStrings(strings, values);
+    let columns;
+    if (hasSQLArrayParameter) {
+      hasSQLArrayParameter = false;
+      const v = values[0];
+      columns = v.columns;
+      values = v.value;
+    }
+
+    return createQuery(sqlString, values, new SQLResultArray(), columns);
+  }
+
   function connectedSQL(strings, values) {
-    return new Query(createQuery(normalizeStrings(strings), values, new SQLResultArray()), connectedHandler);
+    return new Query(doCreateQuery(strings, values), connectedHandler);
   }
 
   function closedSQL(strings, values) {
@@ -327,10 +472,27 @@ function SQL(o) {
   }
 
   function pendingSQL(strings, values) {
-    return new Query(createQuery(normalizeStrings(strings), values, new SQLResultArray()), pendingConnectionHandler);
+    return new Query(doCreateQuery(strings, values), pendingConnectionHandler);
   }
 
   function sql(strings, ...values) {
+    /**
+     * const users = [
+     * {
+     *   name: "Alice",
+     *   age: 25,
+     * },
+     * {
+     *   name: "Bob",
+     *   age: 30,
+     * },
+     * ]
+     * sql`insert into users ${sql(users)}`
+     */
+    if ($isJSArray(strings) && strings[0] && typeof strings[0] === "object") {
+      return new SQLArrayParameter(strings, values);
+    }
+
     if (closed) {
       return closedSQL(strings, values);
     }
@@ -407,6 +569,10 @@ function SQL(o) {
 
 var lazyDefaultSQL;
 var defaultSQLObject = function sql(strings, ...values) {
+  if (new.target) {
+    return SQL(strings);
+  }
+
   if (!lazyDefaultSQL) {
     lazyDefaultSQL = SQL(undefined);
     Object.assign(defaultSQLObject, lazyDefaultSQL);
diff --git a/src/js/internal-for-testing.ts b/src/js/internal-for-testing.ts
index 31b0ca73fd64c6..66f0d31607374d 100644
--- a/src/js/internal-for-testing.ts
+++ b/src/js/internal-for-testing.ts
@@ -113,6 +113,7 @@ export const npm_manifest_test_helpers = $zig("npm.zig", "PackageManifest.bindin
 };
 
 // Like npm-package-arg, sort of https://www.npmjs.com/package/npm-package-arg
+export type Dependency = any;
 export const npa: (name: string) => Dependency = $newZigFunction("dependency.zig", "fromJS", 1);
 
 export const npmTag: (
@@ -141,3 +142,10 @@ export const isModuleResolveFilenameSlowPathEnabled: () => boolean = $newCppFunc
   "jsFunctionIsModuleResolveFilenameSlowPathEnabled",
   0,
 );
+
+export const frameworkRouterInternals = $zig("FrameworkRouter.zig", "JSFrameworkRouter.getBindings") as {
+  parseRoutePattern: () => void;
+  FrameworkRouter: {
+    new(): any;
+  };
+};
diff --git a/src/js/internal/cluster/Worker.ts b/src/js/internal/cluster/Worker.ts
index 14ff825c4dbd2b..4249d1364c67a8 100644
--- a/src/js/internal/cluster/Worker.ts
+++ b/src/js/internal/cluster/Worker.ts
@@ -23,7 +23,7 @@ function Worker(options) {
     this.process.on("message", (message, handle) => this.emit("message", message, handle));
   }
 }
-Worker.prototype = Object.create(EventEmitter.prototype);
+$toClass(Worker, "Worker", EventEmitter);
 
 Worker.prototype.kill = function () {
   this.destroy.$apply(this, arguments);
diff --git a/src/js/internal/promisify.ts b/src/js/internal/promisify.ts
index 76a6ecefc60efa..d9773bca579d56 100644
--- a/src/js/internal/promisify.ts
+++ b/src/js/internal/promisify.ts
@@ -72,6 +72,32 @@ var promisify = function promisify(original) {
 };
 promisify.custom = kCustomPromisifiedSymbol;
 
+// Lazily load node:timers/promises promisified functions onto the global timers.
+{
+  const { setTimeout: timeout, setImmediate: immediate, setInterval: interval } = globalThis;
+
+  if (timeout && $isCallable(timeout)) {
+    defineCustomPromisify(timeout, function setTimeout(arg1) {
+      const fn = defineCustomPromisify(timeout, require("node:timers/promises").setTimeout);
+      return fn.$apply(this, arguments);
+    });
+  }
+
+  if (immediate && $isCallable(immediate)) {
+    defineCustomPromisify(immediate, function setImmediate(arg1) {
+      const fn = defineCustomPromisify(immediate, require("node:timers/promises").setImmediate);
+      return fn.$apply(this, arguments);
+    });
+  }
+
+  if (interval && $isCallable(interval)) {
+    defineCustomPromisify(interval, function setInterval(arg1) {
+      const fn = defineCustomPromisify(interval, require("node:timers/promises").setInterval);
+      return fn.$apply(this, arguments);
+    });
+  }
+}
+
 export default {
   defineCustomPromisify,
   defineCustomPromisifyArgs,
diff --git a/src/js/node/child_process.ts b/src/js/node/child_process.ts
index 440fb1d8c48d51..6767c6206b3edd 100644
--- a/src/js/node/child_process.ts
+++ b/src/js/node/child_process.ts
@@ -563,6 +563,7 @@ function spawnSync(file, args, options) {
     stderr = null,
     success,
     exitCode,
+    signalCode,
   } = Bun.spawnSync({
     cmd: options.args,
     env: options.env || undefined,
@@ -573,7 +574,7 @@ function spawnSync(file, args, options) {
   });
 
   const result = {
-    signal: null,
+    signal: signalCode ?? null,
     status: exitCode,
     // TODO: Need to expose extra pipes from Bun.spawnSync to child_process
     output: [null, stdout, stderr],
diff --git a/src/js/node/fs.ts b/src/js/node/fs.ts
index a9126aa871155a..88b1b7aab323e9 100644
--- a/src/js/node/fs.ts
+++ b/src/js/node/fs.ts
@@ -877,7 +877,7 @@ function ReadStream(this: typeof ReadStream, pathOrFd, options) {
   $assert(overridden_fs);
   this[kFs] = overridden_fs;
 }
-ReadStream.prototype = Object.create(NativeReadable.prototype);
+$toClass(ReadStream, "ReadStream", NativeReadable);
 
 ReadStream.prototype._construct = function (callback) {
   if (NativeReadablePrototype._construct) {
@@ -1185,7 +1185,8 @@ var WriteStreamClass = (WriteStream = function WriteStream(path, options = defau
 });
 
 const NativeWritable = Stream.NativeWritable;
-const WriteStreamPrototype = (WriteStream.prototype = Object.create(NativeWritable.prototype));
+$toClass(WriteStream, "WriteStream", NativeWritable);
+const WriteStreamPrototype = WriteStream.prototype;
 
 Object.defineProperties(WriteStreamPrototype, {
   autoClose: {
diff --git a/src/js/node/http.ts b/src/js/node/http.ts
index 7c3cc0a36bce6b..6c15bf58c41e32 100644
--- a/src/js/node/http.ts
+++ b/src/js/node/http.ts
@@ -277,7 +277,7 @@ function Agent(options = kEmptyObject) {
   this.defaultPort = options.defaultPort || 80;
   this.protocol = options.protocol || "http:";
 }
-Agent.prototype = Object.create(EventEmitter.prototype);
+$toClass(Agent, "Agent", EventEmitter);
 
 ObjectDefineProperty(Agent, "globalAgent", {
   get: function () {
diff --git a/src/js/node/https.ts b/src/js/node/https.ts
index 9f6c66abbdde5b..97522284620993 100644
--- a/src/js/node/https.ts
+++ b/src/js/node/https.ts
@@ -42,7 +42,7 @@ function Agent(options) {
   this.maxCachedSessions = this.options.maxCachedSessions;
   if (this.maxCachedSessions === undefined) this.maxCachedSessions = 100;
 }
-Agent.prototype = Object.create(http.Agent.prototype);
+$toClass(Agent, "Agent", http.Agent);
 Agent.prototype.createConnection = http.createConnection;
 
 var https = {
diff --git a/src/js/node/net.ts b/src/js/node/net.ts
index 4c69705173f171..c9b8ec5de5f6e2 100644
--- a/src/js/node/net.ts
+++ b/src/js/node/net.ts
@@ -1201,11 +1201,23 @@ class Server extends EventEmitter {
 
         hostname = options.host;
         exclusive = options.exclusive === true;
-        const path = options.path;
+        path = options.path;
         port = options.port;
 
+        const isLinux = process.platform === "linux";
+
+
         if (!Number.isSafeInteger(port) || port < 0) {
           if (path) {
+            const isAbstractPath = path.startsWith("\0");
+            if (isLinux && isAbstractPath && (options.writableAll || options.readableAll)) {
+              const message = `The argument 'options' can not set readableAll or writableAll to true when path is abstract unix socket. Received ${JSON.stringify(options)}`;
+
+              const error = new TypeError(message);
+              error.code = "ERR_INVALID_ARG_VALUE";
+              throw error;
+            }
+
             hostname = path;
             port = undefined;
           } else {
@@ -1232,7 +1244,7 @@ class Server extends EventEmitter {
         // ipv6Only <boolean> For TCP servers, setting ipv6Only to true will disable dual-stack support, i.e., binding to host :: won't make 0.0.0.0 be bound. Default: false.
         // signal <AbortSignal> An AbortSignal that may be used to close a listening server.
 
-        if (typeof port.callback === "function") onListen = port?.callback;
+        if (typeof options.callback === "function") onListen = options?.callback;
       } else if (!Number.isSafeInteger(port) || port < 0) {
         port = 0;
       }
diff --git a/src/js/node/stream.ts b/src/js/node/stream.ts
index acbf534cf1994c..874031f49ed3ad 100644
--- a/src/js/node/stream.ts
+++ b/src/js/node/stream.ts
@@ -5441,8 +5441,7 @@ function createNativeStreamReadable(Readable) {
     ptr.onClose = this[_onClose].bind(this);
     ptr.onDrain = this[_onDrain].bind(this);
   }
-  NativeReadable.prototype = {};
-  ObjectSetPrototypeOf(NativeReadable.prototype, Readable.prototype);
+  $toClass(NativeReadable, "NativeReadable", Readable);
 
   NativeReadable.prototype[_onClose] = function () {
     this.push(null);
@@ -5657,8 +5656,7 @@ function NativeWritable(pathOrFdOrSink, options = {}) {
 
   this[_pathOrFdOrSink] = pathOrFdOrSink;
 }
-Object.setPrototypeOf(NativeWritable, Writable);
-NativeWritable.prototype = Object.create(Writable.prototype);
+$toClass(NativeWritable, "NativeWritable", Writable);
 
 // These are confusingly two different fns for construct which initially were the same thing because
 // `_construct` is part of the lifecycle of Writable and is not called lazily,
diff --git a/src/js/node/timers.ts b/src/js/node/timers.ts
index 91f8eb1609e547..9edcdc89c74923 100644
--- a/src/js/node/timers.ts
+++ b/src/js/node/timers.ts
@@ -1,31 +1,5 @@
 const { throwNotImplemented } = require("internal/shared");
-const { defineCustomPromisify } = require("internal/promisify");
 
-// Lazily load node:timers/promises promisified functions onto the global timers.
-{
-  const { setTimeout: timeout, setImmediate: immediate, setInterval: interval } = globalThis;
-
-  if (timeout && $isCallable(timeout)) {
-    defineCustomPromisify(timeout, function setTimeout(arg1) {
-      const fn = defineCustomPromisify(timeout, require("node:timers/promises").setTimeout);
-      return fn.$apply(this, arguments);
-    });
-  }
-
-  if (immediate && $isCallable(immediate)) {
-    defineCustomPromisify(immediate, function setImmediate(arg1) {
-      const fn = defineCustomPromisify(immediate, require("node:timers/promises").setImmediate);
-      return fn.$apply(this, arguments);
-    });
-  }
-
-  if (interval && $isCallable(interval)) {
-    defineCustomPromisify(interval, function setInterval(arg1) {
-      const fn = defineCustomPromisify(interval, require("node:timers/promises").setInterval);
-      return fn.$apply(this, arguments);
-    });
-  }
-}
 var timersPromisesValue;
 
 export default {
diff --git a/src/js/thirdparty/detect-libc.musl.js b/src/js/thirdparty/detect-libc.musl.js
new file mode 100644
index 00000000000000..7ab932c53935ef
--- /dev/null
+++ b/src/js/thirdparty/detect-libc.musl.js
@@ -0,0 +1,38 @@
+// Hardcoded module "detect-libc" for linux
+function family() {
+  return Promise.resolve(familySync());
+}
+
+function familySync() {
+  return MUSL;
+}
+
+const GLIBC = "glibc";
+const MUSL = "musl";
+
+function version() {
+  return Promise.resolve(versionSync());
+}
+
+function versionSync() {
+  return "1.2.5";
+}
+
+function isNonGlibcLinuxSync() {
+  return true;
+}
+
+function isNonGlibcLinux() {
+  return Promise.resolve(isNonGlibcLinuxSync());
+}
+
+export default {
+  GLIBC,
+  MUSL,
+  family,
+  familySync,
+  isNonGlibcLinux,
+  isNonGlibcLinuxSync,
+  version,
+  versionSync,
+};
diff --git a/src/js_ast.zig b/src/js_ast.zig
index 74ddcc0ddbb57f..2d752179ad7e8e 100644
--- a/src/js_ast.zig
+++ b/src/js_ast.zig
@@ -1443,9 +1443,6 @@ pub const OptionalChain = enum(u1) {
 };
 
 pub const E = struct {
-    pub const ToJsOpts = struct {
-        decode_escape_sequences: bool = true,
-    };
     pub const Array = struct {
         items: ExprNodeList = ExprNodeList{},
         comma_after_spread: ?logger.Loc = null,
@@ -1503,13 +1500,13 @@ pub const E = struct {
             return ExprNodeList.init(out[0 .. out.len - remain.len]);
         }
 
-        pub fn toJS(this: @This(), allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject, comptime opts: ToJsOpts) ToJSError!JSC.JSValue {
+        pub fn toJS(this: @This(), allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject) ToJSError!JSC.JSValue {
             const items = this.items.slice();
             var array = JSC.JSValue.createEmptyArray(globalObject, items.len);
             array.protect();
             defer array.unprotect();
             for (items, 0..) |expr, j| {
-                array.putIndex(globalObject, @as(u32, @truncate(j)), try expr.data.toJS(allocator, globalObject, opts));
+                array.putIndex(globalObject, @as(u32, @truncate(j)), try expr.data.toJS(allocator, globalObject));
             }
 
             return array;
@@ -1532,11 +1529,6 @@ pub const E = struct {
         };
     };
 
-    /// A string which will be printed as JSON by the JSPrinter.
-    pub const UTF8String = struct {
-        data: []const u8,
-    };
-
     pub const Unary = struct {
         op: Op.Code,
         value: ExprNodeIndex,
@@ -1550,7 +1542,7 @@ pub const E = struct {
 
     pub const Boolean = struct {
         value: bool,
-        pub fn toJS(this: @This(), ctx: JSC.C.JSContextRef, _: JSC.C.ExceptionRef) JSC.C.JSValueRef {
+        pub fn toJS(this: @This(), ctx: JSC.C.JSContextRef) JSC.C.JSValueRef {
             return JSC.C.JSValueMakeBoolean(ctx, this.value);
         }
     };
@@ -1921,37 +1913,11 @@ pub const E = struct {
             }
         };
 
-        // pub fn toJS(this: Object, ctx: JSC.C.JSContextRef, exception: JSC.C.ExceptionRef) JSC.C.JSValueRef {
-        //     const Creator = struct {
-        //         object: Object,
-        //         pub fn create(this: *@This(), obj: *JSObject, global: *JSGlobalObject) void {
-        //             var iter = this.query.iter();
-        //             var str: ZigString = undefined;
-        //             while (iter.next(&query_string_values_buf)) |entry| {
-        //                 str = ZigString.init(entry.name);
-
-        //                 bun.assert(entry.values.len > 0);
-        //                 if (entry.values.len > 1) {
-        //                     var values = query_string_value_refs_buf[0..entry.values.len];
-        //                     for (entry.values) |value, i| {
-        //                         values[i] = ZigString.init(value);
-        //                     }
-        //                     obj.putRecord(global, &str, values.ptr, values.len);
-        //                 } else {
-        //                     query_string_value_refs_buf[0] = ZigString.init(entry.values[0]);
-
-        //                     obj.putRecord(global, &str, &query_string_value_refs_buf, 1);
-        //                 }
-        //             }
-        //         }
-        //     };
-        // }
-
         pub fn get(self: *const Object, key: string) ?Expr {
             return if (asProperty(self, key)) |query| query.expr else @as(?Expr, null);
         }
 
-        pub fn toJS(this: *Object, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject, comptime opts: ToJsOpts) ToJSError!JSC.JSValue {
+        pub fn toJS(this: *Object, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject) ToJSError!JSC.JSValue {
             var obj = JSC.JSValue.createEmptyObject(globalObject, this.properties.len);
             obj.protect();
             defer obj.unprotect();
@@ -1961,7 +1927,7 @@ pub const E = struct {
                     return error.@"Cannot convert argument type to JS";
                 }
                 var key = prop.key.?.data.e_string.toZigString(allocator);
-                obj.put(globalObject, &key, try prop.value.?.toJS(allocator, globalObject, opts));
+                obj.put(globalObject, &key, try prop.value.?.toJS(allocator, globalObject));
             }
 
             return obj;
@@ -2404,22 +2370,20 @@ pub const E = struct {
             return str.string(allocator);
         }
 
-        pub fn javascriptLength(s: *const String) u32 {
+        pub fn javascriptLength(s: *const String) ?u32 {
             if (s.rope_len > 0) {
                 // We only support ascii ropes for now
                 return s.rope_len;
             }
 
             if (s.isUTF8()) {
-                if (comptime !Environment.isNative) {
-                    const allocated = (strings.toUTF16Alloc(bun.default_allocator, s.data, false, false) catch return 0) orelse return s.data.len;
-                    defer bun.default_allocator.free(allocated);
-                    return @as(u32, @truncate(allocated.len));
+                if (!strings.isAllASCII(s.data)) {
+                    return null;
                 }
-                return @as(u32, @truncate(bun.simdutf.length.utf16.from.utf8(s.data)));
+                return @truncate(s.data.len);
             }
 
-            return @as(u32, @truncate(s.slice16().len));
+            return @truncate(s.slice16().len);
         }
 
         pub inline fn len(s: *const String) usize {
@@ -2521,12 +2485,6 @@ pub const E = struct {
             }
         }
 
-        pub fn stringDecodedUTF8(s: *const String, allocator: std.mem.Allocator) !bun.string {
-            const utf16_decode = try bun.js_lexer.decodeStringLiteralEscapeSequencesToUTF16(try s.string(allocator), allocator);
-            defer allocator.free(utf16_decode);
-            return try bun.strings.toUTF8Alloc(allocator, utf16_decode);
-        }
-
         pub fn hash(s: *const String) u64 {
             if (s.isBlank()) return 0;
 
@@ -2539,33 +2497,31 @@ pub const E = struct {
             }
         }
 
-        pub fn toJS(s: *String, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject, comptime opts: ToJsOpts) JSC.JSValue {
+        pub fn toJS(s: *String, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject) !JSC.JSValue {
+            s.resolveRopeIfNeeded(allocator);
             if (!s.isPresent()) {
                 var emp = bun.String.empty;
                 return emp.toJS(globalObject);
             }
 
-            if (s.is_utf16) {
-                var out, const chars = bun.String.createUninitialized(.utf16, s.len());
+            if (s.isUTF8()) {
+                if (try strings.toUTF16Alloc(allocator, s.slice8(), false, false)) |utf16| {
+                    var out, const chars = bun.String.createUninitialized(.utf16, utf16.len);
+                    defer out.deref();
+                    @memcpy(chars, utf16);
+                    return out.toJS(globalObject);
+                } else {
+                    var out, const chars = bun.String.createUninitialized(.latin1, s.slice8().len);
+                    defer out.deref();
+                    @memcpy(chars, s.slice8());
+                    return out.toJS(globalObject);
+                }
+            } else {
+                var out, const chars = bun.String.createUninitialized(.utf16, s.slice16().len);
                 defer out.deref();
                 @memcpy(chars, s.slice16());
                 return out.toJS(globalObject);
             }
-
-            if (comptime opts.decode_escape_sequences) {
-                s.resolveRopeIfNeeded(allocator);
-
-                const decoded = js_lexer.decodeStringLiteralEscapeSequencesToUTF16(s.slice(allocator), allocator) catch unreachable;
-                defer allocator.free(decoded);
-
-                var out, const chars = bun.String.createUninitialized(.utf16, decoded.len);
-                defer out.deref();
-                @memcpy(chars, decoded);
-
-                return out.toJS(globalObject);
-            } else {
-                return JSC.ZigString.fromUTF8(s.data).toValueGC(globalObject);
-            }
         }
 
         pub fn toZigString(s: *String, allocator: std.mem.Allocator) JSC.ZigString {
@@ -3420,8 +3376,8 @@ pub const Expr = struct {
         return false;
     }
 
-    pub fn toJS(this: Expr, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject, comptime opts: E.ToJsOpts) ToJSError!JSC.JSValue {
-        return this.data.toJS(allocator, globalObject, opts);
+    pub fn toJS(this: Expr, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject) ToJSError!JSC.JSValue {
+        return this.data.toJS(allocator, globalObject);
     }
 
     pub inline fn isArray(this: *const Expr) bool {
@@ -3613,7 +3569,7 @@ pub const Expr = struct {
 
     pub inline fn isString(expr: *const Expr) bool {
         return switch (expr.data) {
-            .e_string, .e_utf8_string => true,
+            .e_string => true,
             else => false,
         };
     }
@@ -3621,7 +3577,6 @@ pub const Expr = struct {
     pub inline fn asString(expr: *const Expr, allocator: std.mem.Allocator) ?string {
         switch (expr.data) {
             .e_string => |str| return str.string(allocator) catch bun.outOfMemory(),
-            .e_utf8_string => |str| return str.data,
             else => return null,
         }
     }
@@ -3633,7 +3588,6 @@ pub const Expr = struct {
                 defer allocator.free(utf8_str);
                 return hash_fn(utf8_str);
             },
-            .e_utf8_string => |str| return hash_fn(str.data),
             else => return null,
         }
     }
@@ -3641,7 +3595,6 @@ pub const Expr = struct {
     pub inline fn asStringCloned(expr: *const Expr, allocator: std.mem.Allocator) OOM!?string {
         switch (expr.data) {
             .e_string => |str| return try str.stringCloned(allocator),
-            .e_utf8_string => |str| return try allocator.dupe(u8, str.data),
             else => return null,
         }
     }
@@ -3649,7 +3602,6 @@ pub const Expr = struct {
     pub inline fn asStringZ(expr: *const Expr, allocator: std.mem.Allocator) OOM!?stringZ {
         switch (expr.data) {
             .e_string => |str| return try str.stringZ(allocator),
-            .e_utf8_string => |str| return try allocator.dupeZ(u8, str.data),
             else => return null,
         }
     }
@@ -3831,18 +3783,6 @@ pub const Expr = struct {
                     },
                 };
             },
-            E.UTF8String => {
-                return Expr{
-                    .loc = loc,
-                    .data = Data{
-                        .e_utf8_string = brk: {
-                            const item = allocator.create(Type) catch unreachable;
-                            item.* = st;
-                            break :brk item;
-                        },
-                    },
-                };
-            },
             E.Class => {
                 return Expr{
                     .loc = loc,
@@ -4253,14 +4193,6 @@ pub const Expr = struct {
         Data.Store.assert();
 
         switch (Type) {
-            E.UTF8String => {
-                return Expr{
-                    .loc = loc,
-                    .data = Data{
-                        .e_utf8_string = Data.Store.append(Type, st),
-                    },
-                };
-            },
             E.Array => {
                 return Expr{
                     .loc = loc,
@@ -4644,9 +4576,6 @@ pub const Expr = struct {
         e_require_main,
         e_inlined_enum,
 
-        /// A string that is UTF-8 encoded without escaping for use in JavaScript.
-        e_utf8_string,
-
         // object, regex and array may have had side effects
         pub fn isPrimitiveLiteral(tag: Tag) bool {
             return switch (tag) {
@@ -5340,7 +5269,6 @@ pub const Expr = struct {
         e_require_main,
 
         e_inlined_enum: *E.InlinedEnum,
-        e_utf8_string: *E.UTF8String,
 
         comptime {
             bun.assert_eql(@sizeOf(Data), 24); // Do not increase the size of Expr
@@ -5800,9 +5728,6 @@ pub const Expr = struct {
                     // pretend there is no comment
                     e.value.data.writeToHasher(hasher, symbol_table);
                 },
-                .e_utf8_string => |e| {
-                    hasher.update(e.data);
-                },
 
                 // no data
                 .e_require_call_target,
@@ -5862,7 +5787,6 @@ pub const Expr = struct {
                 .e_string,
                 .e_inlined_enum,
                 .e_import_meta,
-                .e_utf8_string,
                 => true,
 
                 .e_template => |template| template.tag == null and template.parts.len == 0,
@@ -6264,12 +6188,11 @@ pub const Expr = struct {
             return Equality.unknown;
         }
 
-        pub fn toJS(this: Data, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject, comptime opts: E.ToJsOpts) ToJSError!JSC.JSValue {
+        pub fn toJS(this: Data, allocator: std.mem.Allocator, globalObject: *JSC.JSGlobalObject) ToJSError!JSC.JSValue {
             return switch (this) {
-                .e_array => |e| e.toJS(allocator, globalObject, opts),
-                .e_object => |e| e.toJS(allocator, globalObject, opts),
-                .e_string => |e| e.toJS(allocator, globalObject, opts),
-                .e_utf8_string => |e| JSC.ZigString.fromUTF8(e.data).toJS(globalObject),
+                .e_array => |e| e.toJS(allocator, globalObject),
+                .e_object => |e| e.toJS(allocator, globalObject),
+                .e_string => |e| e.toJS(allocator, globalObject),
                 .e_null => JSC.JSValue.null,
                 .e_undefined => JSC.JSValue.undefined,
                 .e_boolean => |boolean| if (boolean.value)
@@ -6279,7 +6202,7 @@ pub const Expr = struct {
                 .e_number => |e| e.toJS(),
                 // .e_big_int => |e| e.toJS(ctx, exception),
 
-                .e_inlined_enum => |inlined| inlined.value.data.toJS(allocator, globalObject, .{}),
+                .e_inlined_enum => |inlined| inlined.value.data.toJS(allocator, globalObject),
 
                 .e_identifier,
                 .e_import_identifier,
@@ -6325,7 +6248,6 @@ pub const Expr = struct {
                 E.Template,
                 E.TemplatePart,
                 E.Unary,
-                E.UTF8String,
                 E.Yield,
             }, 512);
 
@@ -8502,7 +8424,7 @@ pub const Macro = struct {
             var js_args: []JSC.JSValue = &.{};
             var js_processed_args_len: usize = 0;
             defer {
-                for (js_args[0..js_processed_args_len -| @as(usize, @intFromBool(!javascript_object.isEmpty()))]) |arg| {
+                for (js_args[0..js_processed_args_len -| @as(usize, @intFromBool(javascript_object != .zero))]) |arg| {
                     arg.unprotect();
                 }
 
@@ -8514,14 +8436,13 @@ pub const Macro = struct {
             switch (caller.data) {
                 .e_call => |call| {
                     const call_args: []Expr = call.args.slice();
-                    js_args = try allocator.alloc(JSC.JSValue, call_args.len + @as(usize, @intFromBool(!javascript_object.isEmpty())));
+                    js_args = try allocator.alloc(JSC.JSValue, call_args.len + @as(usize, @intFromBool(javascript_object != .zero)));
                     js_processed_args_len = js_args.len;
 
                     for (0.., call_args, js_args[0..call_args.len]) |i, in, *out| {
                         const value = in.toJS(
                             allocator,
                             globalObject,
-                            .{},
                         ) catch |e| {
                             // Keeping a separate variable instead of modifying js_args.len
                             // due to allocator.free call in defer
@@ -8540,7 +8461,7 @@ pub const Macro = struct {
                 },
             }
 
-            if (!javascript_object.isEmpty()) {
+            if (javascript_object != .zero) {
                 if (js_args.len == 0) {
                     js_args = try allocator.alloc(JSC.JSValue, 1);
                 }
diff --git a/src/js_lexer.zig b/src/js_lexer.zig
index aec6e3c8e6f384..0a4eb1a70348c6 100644
--- a/src/js_lexer.zig
+++ b/src/js_lexer.zig
@@ -74,24 +74,9 @@ pub const JSONOptions = struct {
     /// mark as originally for a macro to enable inlining
     was_originally_macro: bool = false,
 
-    always_decode_escape_sequences: bool = false,
-
     guess_indentation: bool = false,
 };
 
-pub fn decodeStringLiteralEscapeSequencesToUTF16(bytes: string, allocator: std.mem.Allocator) ![]const u16 {
-    var log = logger.Log.init(allocator);
-    defer log.deinit();
-    const source = logger.Source.initEmptyFile("");
-    var lexer = try NewLexer(.{}).init(&log, source, allocator);
-    defer lexer.deinit();
-
-    var buf = std.ArrayList(u16).init(allocator);
-    try lexer.decodeEscapeSequences(0, bytes, @TypeOf(buf), &buf);
-
-    return buf.items;
-}
-
 pub fn NewLexer(
     comptime json_options: JSONOptions,
 ) type {
@@ -103,7 +88,6 @@ pub fn NewLexer(
         json_options.ignore_trailing_escape_sequences,
         json_options.json_warn_duplicate_keys,
         json_options.was_originally_macro,
-        json_options.always_decode_escape_sequences,
         json_options.guess_indentation,
     );
 }
@@ -116,7 +100,6 @@ fn NewLexer_(
     comptime json_options_ignore_trailing_escape_sequences: bool,
     comptime json_options_json_warn_duplicate_keys: bool,
     comptime json_options_was_originally_macro: bool,
-    comptime json_options_always_decode_escape_sequences: bool,
     comptime json_options_guess_indentation: bool,
 ) type {
     const json_options = JSONOptions{
@@ -127,7 +110,6 @@ fn NewLexer_(
         .ignore_trailing_escape_sequences = json_options_ignore_trailing_escape_sequences,
         .json_warn_duplicate_keys = json_options_json_warn_duplicate_keys,
         .was_originally_macro = json_options_was_originally_macro,
-        .always_decode_escape_sequences = json_options_always_decode_escape_sequences,
         .guess_indentation = json_options_guess_indentation,
     };
     return struct {
@@ -187,12 +169,10 @@ fn NewLexer_(
         fn_or_arrow_start_loc: logger.Loc = logger.Loc.Empty,
         regex_flags_start: ?u16 = null,
         allocator: std.mem.Allocator,
-        /// In JavaScript, strings are stored as UTF-16, but nearly every string is ascii.
-        /// This means, usually, we can skip UTF8 -> UTF16 conversions.
-        string_literal_buffer: std.ArrayList(u16),
-        string_literal_slice: string = "",
-        string_literal: JavascriptString,
-        string_literal_is_ascii: bool = false,
+        string_literal_raw_content: string = "",
+        string_literal_start: usize = 0,
+        string_literal_raw_format: enum { ascii, utf16, needs_decode } = .ascii,
+        temp_buffer_u16: std.ArrayList(u16),
 
         /// Only used for JSON stringification when bundling
         /// This is a zero-bit type unless we're parsing JSON.
@@ -210,45 +190,6 @@ fn NewLexer_(
             .{}
         else {},
 
-        pub fn clone(self: *const LexerType) LexerType {
-            return LexerType{
-                .log = self.log,
-                .source = self.source,
-                .current = self.current,
-                .start = self.start,
-                .end = self.end,
-                .did_panic = self.did_panic,
-                .approximate_newline_count = self.approximate_newline_count,
-                .previous_backslash_quote_in_jsx = self.previous_backslash_quote_in_jsx,
-                .token = self.token,
-                .has_newline_before = self.has_newline_before,
-                .has_pure_comment_before = self.has_pure_comment_before,
-                .has_no_side_effect_comment_before = self.has_no_side_effect_comment_before,
-                .preserve_all_comments_before = self.preserve_all_comments_before,
-                .is_legacy_octal_literal = self.is_legacy_octal_literal,
-                .is_log_disabled = self.is_log_disabled,
-                .comments_to_preserve_before = self.comments_to_preserve_before,
-                .code_point = self.code_point,
-                .identifier = self.identifier,
-                .regex_flags_start = self.regex_flags_start,
-                .jsx_pragma = self.jsx_pragma,
-                .source_mapping_url = self.source_mapping_url,
-                .number = self.number,
-                .rescan_close_brace_as_template_token = self.rescan_close_brace_as_template_token,
-                .prev_error_loc = self.prev_error_loc,
-                .allocator = self.allocator,
-                .string_literal_buffer = self.string_literal_buffer,
-                .string_literal_slice = self.string_literal_slice,
-                .string_literal = self.string_literal,
-                .string_literal_is_ascii = self.string_literal_is_ascii,
-                .is_ascii_only = self.is_ascii_only,
-                .all_comments = self.all_comments,
-                .prev_token_was_await_keyword = self.prev_token_was_await_keyword,
-                .await_keyword_loc = self.await_keyword_loc,
-                .fn_or_arrow_start_loc = self.fn_or_arrow_start_loc,
-            };
-        }
-
         pub inline fn loc(self: *const LexerType) logger.Loc {
             return logger.usize2Loc(self.start);
         }
@@ -353,6 +294,7 @@ fn NewLexer_(
         }
 
         pub fn deinit(this: *LexerType) void {
+            this.temp_buffer_u16.clearAndFree();
             this.all_comments.clearAndFree();
             this.comments_to_preserve_before.clearAndFree();
         }
@@ -693,20 +635,15 @@ fn NewLexer_(
             }
         }
 
-        pub const InnerStringLiteral = packed struct { suffix_len: u3, needs_slow_path: bool };
+        pub const InnerStringLiteral = packed struct { suffix_len: u3, needs_decode: bool };
 
-        fn parseStringLiteralInnter(lexer: *LexerType, comptime quote: CodePoint) !InnerStringLiteral {
-            const check_for_backslash = comptime is_json and json_options.always_decode_escape_sequences;
-            var needs_slow_path = false;
+        fn parseStringLiteralInner(lexer: *LexerType, comptime quote: CodePoint) !InnerStringLiteral {
             var suffix_len: u3 = if (comptime quote == 0) 0 else 1;
-            var has_backslash: if (check_for_backslash) bool else void = if (check_for_backslash) false else {};
+            var needs_decode = false;
             stringLiteral: while (true) {
                 switch (lexer.code_point) {
                     '\\' => {
-                        if (comptime check_for_backslash) {
-                            has_backslash = true;
-                        }
-
+                        needs_decode = true;
                         lexer.step();
 
                         // Handle Windows CRLF
@@ -728,14 +665,12 @@ fn NewLexer_(
 
                         switch (lexer.code_point) {
                             // 0 cannot be in this list because it may be a legacy octal literal
-                            'v', 'f', 't', 'r', 'n', '`', '\'', '"', '\\', 0x2028, 0x2029 => {
+                            '`', '\'', '"', '\\' => {
                                 lexer.step();
 
                                 continue :stringLiteral;
                             },
-                            else => {
-                                needs_slow_path = true;
-                            },
+                            else => {},
                         }
                     },
                     // This indicates the end of the file
@@ -754,7 +689,7 @@ fn NewLexer_(
                         }
 
                         // Template literals require newline normalization
-                        needs_slow_path = true;
+                        needs_decode = true;
                     },
 
                     '\n' => {
@@ -799,7 +734,7 @@ fn NewLexer_(
 
                         // Non-ASCII strings need the slow path
                         if (lexer.code_point >= 0x80) {
-                            needs_slow_path = true;
+                            needs_decode = true;
                         } else if (is_json and lexer.code_point < 0x20) {
                             try lexer.syntaxError();
                         } else if (comptime (quote == '"' or quote == '\'') and Environment.isNative) {
@@ -820,9 +755,7 @@ fn NewLexer_(
                 lexer.step();
             }
 
-            if (comptime check_for_backslash) needs_slow_path = needs_slow_path or has_backslash;
-
-            return InnerStringLiteral{ .needs_slow_path = needs_slow_path, .suffix_len = suffix_len };
+            return InnerStringLiteral{ .needs_decode = needs_decode, .suffix_len = suffix_len };
         }
 
         pub fn parseStringLiteral(lexer: *LexerType, comptime quote: CodePoint) !void {
@@ -837,35 +770,20 @@ fn NewLexer_(
             // .env values may not always be quoted.
             lexer.step();
 
-            const string_literal_details = try lexer.parseStringLiteralInnter(quote);
+            const string_literal_details = try lexer.parseStringLiteralInner(quote);
 
             // Reset string literal
             const base = if (comptime quote == 0) lexer.start else lexer.start + 1;
-            lexer.string_literal_slice = lexer.source.contents[base..@min(lexer.source.contents.len, lexer.end - @as(usize, string_literal_details.suffix_len))];
-            lexer.string_literal_is_ascii = !string_literal_details.needs_slow_path;
-            lexer.string_literal_buffer.shrinkRetainingCapacity(0);
-            if (string_literal_details.needs_slow_path) {
-                lexer.string_literal_buffer.ensureUnusedCapacity(lexer.string_literal_slice.len) catch unreachable;
-                try lexer.decodeEscapeSequences(lexer.start, lexer.string_literal_slice, @TypeOf(lexer.string_literal_buffer), &lexer.string_literal_buffer);
-                lexer.string_literal = lexer.string_literal_buffer.items;
-            }
-            if (comptime is_json) lexer.is_ascii_only = lexer.is_ascii_only and lexer.string_literal_is_ascii;
+            lexer.string_literal_raw_content = lexer.source.contents[base..@min(lexer.source.contents.len, lexer.end - @as(usize, string_literal_details.suffix_len))];
+            lexer.string_literal_raw_format = if (string_literal_details.needs_decode) .needs_decode else .ascii;
+            lexer.string_literal_start = lexer.start;
+            if (comptime is_json) lexer.is_ascii_only = lexer.is_ascii_only and !string_literal_details.needs_decode;
 
             if (comptime !FeatureFlags.allow_json_single_quotes) {
                 if (quote == '\'' and is_json) {
                     try lexer.addRangeError(lexer.range(), "JSON strings must use double quotes", .{}, true);
                 }
             }
-
-            // for (text)
-            // // if (needs_slow_path) {
-            // //     // Slow path
-
-            // //     // lexer.string_literal = lexer.(lexer.start + 1, text);
-            // // } else {
-            // //     // Fast path
-
-            // // }
         }
 
         inline fn nextCodepointSlice(it: *LexerType) []const u8 {
@@ -928,7 +846,6 @@ fn NewLexer_(
 
         pub const IdentifierKind = enum { normal, private };
         pub const ScanResult = struct { token: T, contents: string };
-        threadlocal var small_escape_sequence_buffer: [4096]u16 = undefined;
         const FakeArrayList16 = struct {
             items: []u16,
             i: usize = 0,
@@ -948,8 +865,6 @@ fn NewLexer_(
                 bun.assert(fake.items.len > fake.i + int);
             }
         };
-        threadlocal var large_escape_sequence_list: std.ArrayList(u16) = undefined;
-        threadlocal var large_escape_sequence_list_loaded: bool = false;
 
         // This is an edge case that doesn't really exist in the wild, so it doesn't
         // need to be as fast as possible.
@@ -1019,20 +934,12 @@ fn NewLexer_(
 
             // Second pass: re-use our existing escape sequence parser
             const original_text = lexer.raw();
-            if (original_text.len < 1024) {
-                var buf = FakeArrayList16{ .items = &small_escape_sequence_buffer, .i = 0 };
-                try lexer.decodeEscapeSequences(lexer.start, original_text, FakeArrayList16, &buf);
-                result.contents = lexer.utf16ToString(buf.items[0..buf.i]);
-            } else {
-                if (!large_escape_sequence_list_loaded) {
-                    large_escape_sequence_list = try std.ArrayList(u16).initCapacity(lexer.allocator, original_text.len);
-                    large_escape_sequence_list_loaded = true;
-                }
 
-                large_escape_sequence_list.shrinkRetainingCapacity(0);
-                try lexer.decodeEscapeSequences(lexer.start, original_text, std.ArrayList(u16), &large_escape_sequence_list);
-                result.contents = lexer.utf16ToString(large_escape_sequence_list.items);
-            }
+            bun.assert(lexer.temp_buffer_u16.items.len == 0);
+            defer lexer.temp_buffer_u16.clearRetainingCapacity();
+            try lexer.temp_buffer_u16.ensureUnusedCapacity(original_text.len);
+            try lexer.decodeEscapeSequences(lexer.start, original_text, std.ArrayList(u16), &lexer.temp_buffer_u16);
+            result.contents = try lexer.utf16ToString(lexer.temp_buffer_u16.items);
 
             const identifier = if (kind != .private)
                 result.contents
@@ -1064,7 +971,6 @@ fn NewLexer_(
             //
             result.token = if (Keywords.has(result.contents)) .t_escaped_keyword else .t_identifier;
 
-            // const text = lexer.decodeEscapeSequences(lexer.start, lexer.raw(), )
             return result;
         }
 
@@ -2133,14 +2039,11 @@ fn NewLexer_(
         }
 
         pub fn initTSConfig(log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator) !LexerType {
-            const empty_string_literal: JavascriptString = &emptyJavaScriptString;
             var lex = LexerType{
                 .log = log,
                 .source = source,
-                .string_literal = empty_string_literal,
-                .string_literal_buffer = std.ArrayList(u16).init(allocator),
+                .temp_buffer_u16 = std.ArrayList(u16).init(allocator),
                 .prev_error_loc = logger.Loc.Empty,
-                .string_literal_is_ascii = true,
                 .allocator = allocator,
                 .comments_to_preserve_before = std.ArrayList(js_ast.G.Comment).init(allocator),
                 .all_comments = std.ArrayList(logger.Range).init(allocator),
@@ -2152,12 +2055,10 @@ fn NewLexer_(
         }
 
         pub fn initJSON(log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator) !LexerType {
-            const empty_string_literal: JavascriptString = &emptyJavaScriptString;
             var lex = LexerType{
                 .log = log,
-                .string_literal_buffer = std.ArrayList(u16).init(allocator),
                 .source = source,
-                .string_literal = empty_string_literal,
+                .temp_buffer_u16 = std.ArrayList(u16).init(allocator),
                 .prev_error_loc = logger.Loc.Empty,
                 .allocator = allocator,
                 .comments_to_preserve_before = std.ArrayList(js_ast.G.Comment).init(allocator),
@@ -2170,12 +2071,10 @@ fn NewLexer_(
         }
 
         pub fn initWithoutReading(log: *logger.Log, source: logger.Source, allocator: std.mem.Allocator) LexerType {
-            const empty_string_literal: JavascriptString = &emptyJavaScriptString;
             return LexerType{
                 .log = log,
                 .source = source,
-                .string_literal = empty_string_literal,
-                .string_literal_buffer = std.ArrayList(u16).init(allocator),
+                .temp_buffer_u16 = std.ArrayList(u16).init(allocator),
                 .prev_error_loc = logger.Loc.Empty,
                 .allocator = allocator,
                 .comments_to_preserve_before = std.ArrayList(js_ast.G.Comment).init(allocator),
@@ -2191,22 +2090,40 @@ fn NewLexer_(
             return lex;
         }
 
-        pub fn toEString(lexer: *LexerType) js_ast.E.String {
-            if (lexer.string_literal_is_ascii) {
-                return js_ast.E.String.init(lexer.string_literal_slice);
-            } else {
-                return js_ast.E.String.init(lexer.allocator.dupe(u16, lexer.string_literal) catch unreachable);
+        pub fn toEString(lexer: *LexerType) !js_ast.E.String {
+            switch (lexer.string_literal_raw_format) {
+                .ascii => {
+                    // string_literal_raw_content contains ascii without escapes
+                    return js_ast.E.String.init(lexer.string_literal_raw_content);
+                },
+                .utf16 => {
+                    // string_literal_raw_content is already parsed, duplicated, and utf-16
+                    return js_ast.E.String.init(@as([]const u16, @alignCast(std.mem.bytesAsSlice(u16, lexer.string_literal_raw_content))));
+                },
+                .needs_decode => {
+                    // string_literal_raw_content contains escapes (ie '\n') that need to be converted to their values (ie 0x0A).
+                    // escape parsing may cause a syntax error.
+                    bun.assert(lexer.temp_buffer_u16.items.len == 0);
+                    defer lexer.temp_buffer_u16.clearRetainingCapacity();
+                    try lexer.temp_buffer_u16.ensureUnusedCapacity(lexer.string_literal_raw_content.len);
+                    try lexer.decodeEscapeSequences(lexer.string_literal_start, lexer.string_literal_raw_content, std.ArrayList(u16), &lexer.temp_buffer_u16);
+                    const first_non_ascii = strings.firstNonASCII16([]const u16, lexer.temp_buffer_u16.items);
+                    // prefer to store an ascii e.string rather than a utf-16 one. ascii takes less memory, and `+` folding is not yet supported on utf-16.
+                    if (first_non_ascii != null) {
+                        return js_ast.E.String.init(try lexer.allocator.dupe(u16, lexer.temp_buffer_u16.items));
+                    } else {
+                        const result = try lexer.allocator.alloc(u8, lexer.temp_buffer_u16.items.len);
+                        strings.copyU16IntoU8(result, []const u16, lexer.temp_buffer_u16.items);
+                        return js_ast.E.String.init(result);
+                    }
+                },
             }
         }
 
-        pub fn toUTF8EString(lexer: *LexerType) js_ast.E.String {
-            if (lexer.string_literal_is_ascii) {
-                return js_ast.E.String.init(lexer.string_literal_slice);
-            } else {
-                var e_str = js_ast.E.String.init(lexer.string_literal);
-                e_str.toUTF8(lexer.allocator) catch unreachable;
-                return e_str;
-            }
+        pub fn toUTF8EString(lexer: *LexerType) !js_ast.E.String {
+            var res = try lexer.toEString();
+            try res.toUTF8(lexer.allocator);
+            return res;
         }
 
         inline fn assertNotJSON(_: *const LexerType) void {
@@ -2276,32 +2193,9 @@ fn NewLexer_(
             }
         }
 
-        // TODO: use wtf-8 encoding.
-        pub fn utf16ToStringWithValidation(lexer: *LexerType, js: JavascriptString) !string {
-            // return std.unicode.utf16leToUtf8Alloc(lexer.allocator, js);
-            return utf16ToString(lexer, js);
+        pub fn utf16ToString(lexer: *LexerType, js: JavascriptString) !string {
+            return try strings.toUTF8AllocWithType(lexer.allocator, []const u16, js);
         }
-
-        pub fn utf16ToString(lexer: *LexerType, js: JavascriptString) string {
-            var temp: [4]u8 = undefined;
-            var list = std.ArrayList(u8).initCapacity(lexer.allocator, js.len) catch unreachable;
-            var i: usize = 0;
-            while (i < js.len) : (i += 1) {
-                var r1 = @as(i32, @intCast(js[i]));
-                if (r1 >= 0xD800 and r1 <= 0xDBFF and i + 1 < js.len) {
-                    const r2 = @as(i32, @intCast(js[i] + 1));
-                    if (r2 >= 0xDC00 and r2 <= 0xDFFF) {
-                        r1 = (r1 - 0xD800) << 10 | (r2 - 0xDC00) + 0x10000;
-                        i += 1;
-                    }
-                }
-                const width = strings.encodeWTF8Rune(&temp, r1);
-                list.appendSlice(temp[0..width]) catch unreachable;
-            }
-            return list.items;
-            // return std.unicode.utf16leToUtf8Alloc(lexer.allocator, js) catch unreachable;
-        }
-
         pub fn nextInsideJSXElement(lexer: *LexerType) !void {
             lexer.assertNotJSON();
 
@@ -2508,13 +2402,19 @@ fn NewLexer_(
             }
 
             lexer.token = .t_string_literal;
-            lexer.string_literal_slice = lexer.source.contents[lexer.start + 1 .. lexer.end - 1];
-            lexer.string_literal_is_ascii = !needs_decode;
-            lexer.string_literal_buffer.clearRetainingCapacity();
+
+            const raw_content_slice = lexer.source.contents[lexer.start + 1 .. lexer.end - 1];
             if (needs_decode) {
-                lexer.string_literal_buffer.ensureTotalCapacity(lexer.string_literal_slice.len) catch unreachable;
-                try lexer.decodeJSXEntities(lexer.string_literal_slice, &lexer.string_literal_buffer);
-                lexer.string_literal = lexer.string_literal_buffer.items;
+                bun.assert(lexer.temp_buffer_u16.items.len == 0);
+                defer lexer.temp_buffer_u16.clearRetainingCapacity();
+                try lexer.temp_buffer_u16.ensureUnusedCapacity(raw_content_slice.len);
+                try lexer.fixWhitespaceAndDecodeJSXEntities(raw_content_slice, &lexer.temp_buffer_u16);
+
+                lexer.string_literal_raw_content = std.mem.sliceAsBytes(try lexer.allocator.dupe(u16, lexer.temp_buffer_u16.items));
+                lexer.string_literal_raw_format = .utf16;
+            } else {
+                lexer.string_literal_raw_content = raw_content_slice;
+                lexer.string_literal_raw_format = .ascii;
             }
         }
 
@@ -2574,18 +2474,23 @@ fn NewLexer_(
                         }
 
                         lexer.token = .t_string_literal;
-                        lexer.string_literal_slice = lexer.source.contents[original_start..lexer.end];
-                        lexer.string_literal_is_ascii = !needs_fixing;
-                        if (needs_fixing) {
-                            // slow path
-                            lexer.string_literal = try fixWhitespaceAndDecodeJSXEntities(lexer, lexer.string_literal_slice);
+                        const raw_content_slice = lexer.source.contents[original_start..lexer.end];
 
-                            if (lexer.string_literal.len == 0) {
+                        if (needs_fixing) {
+                            bun.assert(lexer.temp_buffer_u16.items.len == 0);
+                            defer lexer.temp_buffer_u16.clearRetainingCapacity();
+                            try lexer.temp_buffer_u16.ensureUnusedCapacity(raw_content_slice.len);
+                            try lexer.fixWhitespaceAndDecodeJSXEntities(raw_content_slice, &lexer.temp_buffer_u16);
+                            lexer.string_literal_raw_content = std.mem.sliceAsBytes(try lexer.allocator.dupe(u16, lexer.temp_buffer_u16.items));
+                            lexer.string_literal_raw_format = .utf16;
+
+                            if (lexer.temp_buffer_u16.items.len == 0) {
                                 lexer.has_newline_before = true;
                                 continue;
                             }
                         } else {
-                            lexer.string_literal = &([_]u16{});
+                            lexer.string_literal_raw_content = raw_content_slice;
+                            lexer.string_literal_raw_format = .ascii;
                         }
                     },
                 }
@@ -2594,21 +2499,9 @@ fn NewLexer_(
             }
         }
 
-        threadlocal var jsx_decode_buf: std.ArrayList(u16) = undefined;
-        threadlocal var jsx_decode_init = false;
-        pub fn fixWhitespaceAndDecodeJSXEntities(lexer: *LexerType, text: string) !JavascriptString {
+        pub fn fixWhitespaceAndDecodeJSXEntities(lexer: *LexerType, text: string, decoded: *std.ArrayList(u16)) !void {
             lexer.assertNotJSON();
 
-            if (!jsx_decode_init) {
-                jsx_decode_init = true;
-                jsx_decode_buf = std.ArrayList(u16).init(default_allocator);
-            }
-            jsx_decode_buf.clearRetainingCapacity();
-
-            var decoded = jsx_decode_buf;
-            defer jsx_decode_buf = decoded;
-            const decoded_ptr = &decoded;
-
             var after_last_non_whitespace: ?u32 = null;
 
             // Trim whitespace off the end of the first line
@@ -2627,7 +2520,7 @@ fn NewLexer_(
                             }
 
                             // Trim whitespace off the start and end of lines in the middle
-                            try lexer.decodeJSXEntities(text[first_non_whitespace.?..after_last_non_whitespace.?], &decoded);
+                            try lexer.decodeJSXEntities(text[first_non_whitespace.?..after_last_non_whitespace.?], decoded);
                         }
 
                         // Reset for the next line
@@ -2651,10 +2544,8 @@ fn NewLexer_(
                     try decoded.append(' ');
                 }
 
-                try decodeJSXEntities(lexer, text[start..text.len], decoded_ptr);
+                try decodeJSXEntities(lexer, text[start..text.len], decoded);
             }
-
-            return decoded.items;
         }
 
         fn maybeDecodeJSXEntity(lexer: *LexerType, text: string, cursor: *strings.CodepointIterator.Cursor) void {
diff --git a/src/js_parser.zig b/src/js_parser.zig
index da72afcb552598..e558cc27f51f03 100644
--- a/src/js_parser.zig
+++ b/src/js_parser.zig
@@ -3516,7 +3516,7 @@ pub const Parser = struct {
                     decls[0] = .{
                         .binding = p.b(B.Identifier{ .ref = p.dirname_ref }, logger.Loc.Empty),
                         .value = p.newExpr(
-                            E.UTF8String{
+                            E.String{
                                 .data = p.source.path.name.dir,
                             },
                             logger.Loc.Empty,
@@ -3528,7 +3528,7 @@ pub const Parser = struct {
                     decls[@as(usize, @intFromBool(uses_dirname))] = .{
                         .binding = p.b(B.Identifier{ .ref = p.filename_ref }, logger.Loc.Empty),
                         .value = p.newExpr(
-                            E.UTF8String{
+                            E.String{
                                 .data = p.source.path.text,
                             },
                             logger.Loc.Empty,
@@ -11068,7 +11068,7 @@ fn NewParser_(
             if (strings.eqlComptime(name, "require") and p.lexer.token == .t_open_paren) {
                 // "import ns = require('x')"
                 try p.lexer.next();
-                const path = p.newExpr(p.lexer.toEString(), p.lexer.loc());
+                const path = p.newExpr(try p.lexer.toEString(), p.lexer.loc());
                 try p.lexer.expect(.t_string_literal);
                 try p.lexer.expect(.t_close_paren);
                 if (!opts.is_typescript_declare) {
@@ -11106,16 +11106,16 @@ fn NewParser_(
         fn parseClauseAlias(p: *P, kind: string) !string {
             const loc = p.lexer.loc();
 
-            // The alias may now be a string (see https://github.com/tc39/ecma262/pull/2154)
+            // The alias may now be a utf-16 (not wtf-16) string (see https://github.com/tc39/ecma262/pull/2154)
             if (p.lexer.token == .t_string_literal) {
-                if (p.lexer.string_literal_is_ascii) {
-                    return p.lexer.string_literal_slice;
-                } else if (p.lexer.utf16ToStringWithValidation(p.lexer.string_literal)) |alias| {
-                    return alias;
-                } else |_| {
+                var estr = try p.lexer.toEString();
+                if (estr.isUTF8()) {
+                    return estr.slice8();
+                } else if (strings.toUTF8AllocWithTypeWithoutInvalidSurrogatePairs(p.lexer.allocator, []const u16, estr.slice16())) |alias_utf8| {
+                    return alias_utf8;
+                } else |err| {
                     const r = p.source.rangeOfString(loc);
-                    // TODO: improve error message
-                    try p.log.addRangeErrorFmt(p.source, r, p.allocator, "Invalid {s} alias because it contains an unpaired Unicode surrogate (like emoji)", .{kind});
+                    try p.log.addRangeErrorFmt(p.source, r, p.allocator, "Invalid {s} alias because it contains an unpaired Unicode surrogate ({s})", .{ kind, @errorName(err) });
                     return p.source.textForRange(r);
                 }
             }
@@ -11789,7 +11789,7 @@ fn NewParser_(
 
                 // Parse the name
                 if (p.lexer.token == .t_string_literal) {
-                    value.name = p.lexer.toUTF8EString().data;
+                    value.name = (try p.lexer.toUTF8EString()).slice8();
                     needs_symbol = js_lexer.isIdentifier(value.name);
                 } else if (p.lexer.isIdentifierOrKeyword()) {
                     value.name = p.lexer.identifier;
@@ -12138,9 +12138,10 @@ fn NewParser_(
         }
 
         pub fn parsePath(p: *P) !ParsedPath {
+            const path_text = try p.lexer.toUTF8EString();
             var path = ParsedPath{
                 .loc = p.lexer.loc(),
-                .text = p.lexer.string_literal_slice,
+                .text = path_text.slice8(),
                 .is_macro = false,
                 .import_tag = .none,
             };
@@ -12180,11 +12181,10 @@ fn NewParser_(
                                 }
                             }
                         } else if (p.lexer.token == .t_string_literal) {
-                            if (p.lexer.string_literal_is_ascii) {
-                                inline for (comptime std.enums.values(SupportedAttribute)) |t| {
-                                    if (strings.eqlComptime(p.lexer.string_literal_slice, @tagName(t))) {
-                                        break :brk t;
-                                    }
+                            const string_literal_text = (try p.lexer.toUTF8EString()).slice8();
+                            inline for (comptime std.enums.values(SupportedAttribute)) |t| {
+                                if (strings.eqlComptime(string_literal_text, @tagName(t))) {
+                                    break :brk t;
                                 }
                             }
                         } else {
@@ -12198,44 +12198,43 @@ fn NewParser_(
                     try p.lexer.expect(.t_colon);
 
                     try p.lexer.expect(.t_string_literal);
-                    if (p.lexer.string_literal_is_ascii) {
-                        if (supported_attribute) |attr| {
-                            switch (attr) {
-                                .type => {
-                                    const type_attr = p.lexer.string_literal_slice;
-                                    if (strings.eqlComptime(type_attr, "macro")) {
-                                        path.is_macro = true;
-                                    } else if (strings.eqlComptime(type_attr, "sqlite")) {
-                                        path.import_tag = .with_type_sqlite;
-                                        if (has_seen_embed_true) {
-                                            path.import_tag = .with_type_sqlite_embedded;
-                                        }
-                                    } else if (strings.eqlComptime(type_attr, "json")) {
-                                        path.import_tag = .with_type_json;
-                                    } else if (strings.eqlComptime(type_attr, "toml")) {
-                                        path.import_tag = .with_type_toml;
-                                    } else if (strings.eqlComptime(type_attr, "text")) {
-                                        path.import_tag = .with_type_text;
-                                    } else if (strings.eqlComptime(type_attr, "file")) {
-                                        path.import_tag = .with_type_file;
-                                    }
-                                },
-                                .embed => {
-                                    if (strings.eqlComptime(p.lexer.string_literal_slice, "true")) {
-                                        has_seen_embed_true = true;
-                                        if (path.import_tag == .with_type_sqlite) {
-                                            path.import_tag = .with_type_sqlite_embedded;
-                                        }
+                    const string_literal_text = (try p.lexer.toUTF8EString()).slice8();
+                    if (supported_attribute) |attr| {
+                        switch (attr) {
+                            .type => {
+                                const type_attr = string_literal_text;
+                                if (strings.eqlComptime(type_attr, "macro")) {
+                                    path.is_macro = true;
+                                } else if (strings.eqlComptime(type_attr, "sqlite")) {
+                                    path.import_tag = .with_type_sqlite;
+                                    if (has_seen_embed_true) {
+                                        path.import_tag = .with_type_sqlite_embedded;
                                     }
-                                },
-                                .bunBakeGraph => {
-                                    if (strings.eqlComptime(p.lexer.string_literal_slice, "ssr")) {
-                                        path.import_tag = .bake_resolve_to_ssr_graph;
-                                    } else {
-                                        try p.lexer.addRangeError(p.lexer.range(), "'bunBakeGraph' can only be set to 'ssr'", .{}, true);
+                                } else if (strings.eqlComptime(type_attr, "json")) {
+                                    path.import_tag = .with_type_json;
+                                } else if (strings.eqlComptime(type_attr, "toml")) {
+                                    path.import_tag = .with_type_toml;
+                                } else if (strings.eqlComptime(type_attr, "text")) {
+                                    path.import_tag = .with_type_text;
+                                } else if (strings.eqlComptime(type_attr, "file")) {
+                                    path.import_tag = .with_type_file;
+                                }
+                            },
+                            .embed => {
+                                if (strings.eqlComptime(string_literal_text, "true")) {
+                                    has_seen_embed_true = true;
+                                    if (path.import_tag == .with_type_sqlite) {
+                                        path.import_tag = .with_type_sqlite_embedded;
                                     }
-                                },
-                            }
+                                }
+                            },
+                            .bunBakeGraph => {
+                                if (strings.eqlComptime(string_literal_text, "ssr")) {
+                                    path.import_tag = .bake_resolve_to_ssr_graph;
+                                } else {
+                                    try p.lexer.addRangeError(p.lexer.range(), "'bunBakeGraph' can only be set to 'ssr'", .{}, true);
+                                }
+                            },
                         }
                     }
 
@@ -13788,7 +13787,7 @@ fn NewParser_(
                 try p.lexer.rescanCloseBraceAsTemplateToken();
 
                 const tail: E.Template.Contents = brk: {
-                    if (!include_raw) break :brk .{ .cooked = p.lexer.toEString() };
+                    if (!include_raw) break :brk .{ .cooked = try p.lexer.toEString() };
                     break :brk .{ .raw = p.lexer.rawTemplateContents() };
                 };
 
@@ -13814,7 +13813,7 @@ fn NewParser_(
         // This assumes the caller has already checked for TStringLiteral or TNoSubstitutionTemplateLiteral
         pub fn parseStringLiteral(p: *P) anyerror!Expr {
             const loc = p.lexer.loc();
-            var str = p.lexer.toEString();
+            var str = try p.lexer.toEString();
             str.prefer_template = p.lexer.token == .t_no_substitution_template_literal;
 
             const expr = p.newExpr(str, loc);
@@ -14899,7 +14898,7 @@ fn NewParser_(
                     return try p.parseStringLiteral();
                 },
                 .t_template_head => {
-                    const head = p.lexer.toEString();
+                    const head = try p.lexer.toEString();
 
                     const parts = try p.parseTemplateParts(false);
 
@@ -15486,7 +15485,7 @@ fn NewParser_(
             try p.lexer.nextInsideJSXElement();
             if (p.lexer.token == .t_string_literal) {
                 previous_string_with_backslash_loc.start = @max(p.lexer.loc().start, p.lexer.previous_backslash_quote_in_jsx.loc.start);
-                const expr = p.newExpr(p.lexer.toEString(), previous_string_with_backslash_loc.*);
+                const expr = p.newExpr(try p.lexer.toEString(), previous_string_with_backslash_loc.*);
 
                 try p.lexer.nextInsideJSXElement();
                 return expr;
@@ -15622,7 +15621,7 @@ fn NewParser_(
                                 //  <div foo="foo" />
                                 // note: template literals are not supported, operations on strings are not supported either
                                 T.t_string_literal => {
-                                    const key = p.newExpr(p.lexer.toEString(), p.lexer.loc());
+                                    const key = p.newExpr(try p.lexer.toEString(), p.lexer.loc());
                                     try p.lexer.next();
                                     try props.append(G.Property{ .value = key, .key = key, .kind = .normal });
                                 },
@@ -15695,7 +15694,7 @@ fn NewParser_(
             while (true) {
                 switch (p.lexer.token) {
                     .t_string_literal => {
-                        try children.append(p.newExpr(p.lexer.toEString(), loc));
+                        try children.append(p.newExpr(try p.lexer.toEString(), loc));
                         try p.lexer.nextJSXElementChild();
                     },
                     .t_open_brace => {
@@ -17494,6 +17493,31 @@ fn NewParser_(
                         p.handleReactRefreshHookCall(e_, original_name);
                     }
 
+                    // Implement constant folding for 'string'.charCodeAt(n)
+                    if (e_.args.len == 1) if (e_.target.data.as(.e_dot)) |dot| {
+                        if (dot.target.data == .e_string and
+                            dot.target.data.e_string.isUTF8() and
+                            bun.strings.eqlComptime(dot.name, "charCodeAt"))
+                        {
+                            const str = dot.target.data.e_string.data;
+                            const arg1 = e_.args.at(0).unwrapInlined();
+                            if (arg1.data == .e_number) {
+                                const float = arg1.data.e_number.value;
+                                if (@mod(float, 1) == 0 and
+                                    float < @as(f64, @floatFromInt(str.len)) and
+                                    float >= 0)
+                                {
+                                    const char = str[@intFromFloat(float)];
+                                    if (char < 0x80) {
+                                        return p.newExpr(E.Number{
+                                            .value = @floatFromInt(char),
+                                        }, expr.loc);
+                                    }
+                                }
+                            }
+                        }
+                    };
+
                     return expr;
                 },
                 .e_new => |e_| {
@@ -18683,12 +18707,11 @@ fn NewParser_(
                 },
                 // TODO: e_inlined_enum -> .e_string -> "length" should inline the length
                 .e_string => |str| {
-                    // Disable until https://github.com/oven-sh/bun/issues/4217 is fixed
-                    if (comptime FeatureFlags.minify_javascript_string_length) {
-                        if (p.options.features.minify_syntax) {
-                            // minify "long-string".length to 11
-                            if (strings.eqlComptime(name, "length")) {
-                                return p.newExpr(E.Number{ .value = @floatFromInt(str.javascriptLength()) }, loc);
+                    if (p.options.features.minify_syntax) {
+                        // minify "long-string".length to 11
+                        if (strings.eqlComptime(name, "length")) {
+                            if (str.javascriptLength()) |len| {
+                                return p.newExpr(E.Number{ .value = @floatFromInt(len) }, loc);
                             }
                         }
                     }
diff --git a/src/js_printer.zig b/src/js_printer.zig
index 0ffdf9ef47f688..db4a65a37de9a4 100644
--- a/src/js_printer.zig
+++ b/src/js_printer.zig
@@ -82,9 +82,9 @@ pub fn writeModuleId(comptime Writer: type, writer: Writer, module_id: u32) void
 
 pub fn canPrintWithoutEscape(comptime CodePointType: type, c: CodePointType, comptime ascii_only: bool) bool {
     if (c <= last_ascii) {
-        return c >= first_ascii and c != '\\' and c != '"';
+        return c >= first_ascii and c != '\\' and c != '"' and c != '\'' and c != '`' and c != '$';
     } else {
-        return !ascii_only and c != 0xFEFF and (c < first_high_surrogate or c > last_low_surrogate);
+        return !ascii_only and c != 0xFEFF and c != 0x2028 and c != 0x2029 and (c < first_high_surrogate or c > last_low_surrogate);
     }
 }
 
@@ -95,9 +95,8 @@ pub fn bestQuoteCharForString(comptime Type: type, str: []const Type, allow_back
     var single_cost: usize = 0;
     var double_cost: usize = 0;
     var backtick_cost: usize = 0;
-    var char: u8 = 0;
     var i: usize = 0;
-    while (i < str.len) {
+    while (i < @min(str.len, 1024)) {
         switch (str[i]) {
             '\'' => {
                 single_cost += 1;
@@ -108,10 +107,9 @@ pub fn bestQuoteCharForString(comptime Type: type, str: []const Type, allow_back
             '`' => {
                 backtick_cost += 1;
             },
-            '\r', '\n' => {
-                if (allow_backtick) {
-                    return '`';
-                }
+            '\n' => {
+                single_cost += 1;
+                double_cost += 1;
             },
             '\\' => {
                 i += 1;
@@ -126,18 +124,13 @@ pub fn bestQuoteCharForString(comptime Type: type, str: []const Type, allow_back
         i += 1;
     }
 
-    char = '"';
-    if (double_cost > single_cost) {
-        char = '\'';
-
-        if (single_cost > backtick_cost and allow_backtick) {
-            char = '`';
-        }
-    } else if (double_cost > backtick_cost and allow_backtick) {
-        char = '`';
+    if (allow_backtick and backtick_cost < @min(single_cost, double_cost)) {
+        return '`';
     }
-
-    return char;
+    if (single_cost < double_cost) {
+        return '\'';
+    }
+    return '"';
 }
 
 const Whitespacer = struct {
@@ -170,11 +163,11 @@ fn ws(comptime str: []const u8) Whitespacer {
     return .{ .normal = Static.with, .minify = Static.without };
 }
 
-pub fn estimateLengthForJSON(input: []const u8, comptime ascii_only: bool) usize {
+pub fn estimateLengthForUTF8(input: []const u8, comptime ascii_only: bool, comptime quote_char: u8) usize {
     var remaining = input;
     var len: usize = 2; // for quotes
 
-    while (strings.indexOfNeedsEscape(remaining)) |i| {
+    while (strings.indexOfNeedsEscape(remaining, quote_char)) |i| {
         len += i;
         remaining = remaining[i..];
         const char_len = strings.wtf8ByteSequenceLengthWithInvalid(remaining[0]);
@@ -212,222 +205,163 @@ pub fn quoteForJSON(text: []const u8, output_: MutableString, comptime ascii_onl
     return bytes;
 }
 
-pub fn quoteForJSONBuffer(text: []const u8, bytes: *MutableString, comptime ascii_only: bool) !void {
-    try bytes.growIfNeeded(estimateLengthForJSON(text, ascii_only));
-    try bytes.appendChar('"');
+pub fn writePreQuotedString(text_in: []const u8, comptime Writer: type, writer: Writer, comptime quote_char: u8, comptime ascii_only: bool, comptime json: bool, comptime encoding: strings.Encoding) !void {
+    const text = if (comptime encoding == .utf16) @as([]const u16, @alignCast(std.mem.bytesAsSlice(u16, text_in))) else text_in;
     var i: usize = 0;
     const n: usize = text.len;
     while (i < n) {
-        const width = strings.wtf8ByteSequenceLengthWithInvalid(text[i]);
+        const width = switch (comptime encoding) {
+            .latin1, .ascii => 1,
+            .utf8 => strings.wtf8ByteSequenceLengthWithInvalid(text[i]),
+            .utf16 => 1,
+        };
         const clamped_width = @min(@as(usize, width), n -| i);
-        const c = strings.decodeWTF8RuneT(
-            &switch (clamped_width) {
-                // 0 is not returned by `wtf8ByteSequenceLengthWithInvalid`
-                1 => .{ text[i], 0, 0, 0 },
-                2 => text[i..][0..2].* ++ .{ 0, 0 },
-                3 => text[i..][0..3].* ++ .{0},
-                4 => text[i..][0..4].*,
-                else => unreachable,
+        const c = switch (encoding) {
+            .utf8 => strings.decodeWTF8RuneT(
+                &switch (clamped_width) {
+                    // 0 is not returned by `wtf8ByteSequenceLengthWithInvalid`
+                    1 => .{ text[i], 0, 0, 0 },
+                    2 => text[i..][0..2].* ++ .{ 0, 0 },
+                    3 => text[i..][0..3].* ++ .{0},
+                    4 => text[i..][0..4].*,
+                    else => unreachable,
+                },
+                width,
+                i32,
+                0,
+            ),
+            .ascii => brk: {
+                std.debug.assert(text[i] <= 0x7F);
+                break :brk text[i];
             },
-            width,
-            i32,
-            0,
-        );
+            .latin1 => brk: {
+                if (text[i] <= 0x7F) break :brk text[i];
+                break :brk strings.latin1ToCodepointAssumeNotASCII(text[i], i32);
+            },
+            .utf16 => brk: {
+                // TODO: if this is a part of a surrogate pair, we could parse the whole codepoint in order
+                // to emit it as a single \u{result} rather than two paired \uLOW\uHIGH.
+                // eg: "\u{10334}" will convert to "\uD800\uDF34" without this.
+                break :brk @as(i32, text[i]);
+            },
+        };
         if (canPrintWithoutEscape(i32, c, ascii_only)) {
             const remain = text[i + clamped_width ..];
-            if (strings.indexOfNeedsEscape(remain)) |j| {
-                const text_chunk = text[i .. i + clamped_width];
-                try bytes.appendSlice(text_chunk);
-                i += clamped_width;
-                try bytes.appendSlice(remain[0..j]);
-                i += j;
-                continue;
-            } else {
-                try bytes.appendSlice(text[i..]);
-                i = n;
-                break;
+
+            switch (encoding) {
+                .ascii, .utf8 => {
+                    if (strings.indexOfNeedsEscape(remain, quote_char)) |j| {
+                        const text_chunk = text[i .. i + clamped_width];
+                        try writer.writeAll(text_chunk);
+                        i += clamped_width;
+                        try writer.writeAll(remain[0..j]);
+                        i += j;
+                    } else {
+                        try writer.writeAll(text[i..]);
+                        i = n;
+                        break;
+                    }
+                },
+                .latin1, .utf16 => {
+                    var codepoint_bytes: [4]u8 = undefined;
+                    const codepoint_len = strings.encodeWTF8Rune(codepoint_bytes[0..4], c);
+                    try writer.writeAll(codepoint_bytes[0..codepoint_len]);
+                    i += clamped_width;
+                },
             }
+            continue;
         }
         switch (c) {
             0x07 => {
-                try bytes.appendSlice("\\x07");
+                try writer.writeAll("\\x07");
                 i += 1;
             },
             0x08 => {
-                try bytes.appendSlice("\\b");
+                try writer.writeAll("\\b");
                 i += 1;
             },
             0x0C => {
-                try bytes.appendSlice("\\f");
+                try writer.writeAll("\\f");
                 i += 1;
             },
             '\n' => {
-                try bytes.appendSlice("\\n");
+                if (quote_char == '`') {
+                    try writer.writeAll("\n");
+                } else {
+                    try writer.writeAll("\\n");
+                }
                 i += 1;
             },
             std.ascii.control_code.cr => {
-                try bytes.appendSlice("\\r");
+                try writer.writeAll("\\r");
                 i += 1;
             },
             // \v
             std.ascii.control_code.vt => {
-                try bytes.appendSlice("\\v");
+                try writer.writeAll("\\v");
                 i += 1;
             },
             // "\\"
             '\\' => {
-                try bytes.appendSlice("\\\\");
+                try writer.writeAll("\\\\");
                 i += 1;
             },
             '"' => {
-                try bytes.appendSlice("\\\"");
+                if (quote_char == '"') {
+                    try writer.writeAll("\\\"");
+                } else {
+                    try writer.writeAll("\"");
+                }
                 i += 1;
             },
-
-            '\t' => {
-                try bytes.appendSlice("\\t");
+            '\'' => {
+                if (quote_char == '\'') {
+                    try writer.writeAll("\\'");
+                } else {
+                    try writer.writeAll("'");
+                }
                 i += 1;
             },
-
-            else => {
-                i += @as(usize, width);
-
-                if (c < 0xFFFF) {
-                    const k = @as(usize, @intCast(c));
-                    bytes.ensureUnusedCapacity(6) catch unreachable;
-                    const old = bytes.list.items.len;
-                    bytes.list.items.len += 6;
-
-                    bytes.list.items[old .. old + 6].ptr[0..6].* = [_]u8{
-                        '\\',
-                        'u',
-                        hex_chars[(k >> 12) & 0xF],
-                        hex_chars[(k >> 8) & 0xF],
-                        hex_chars[(k >> 4) & 0xF],
-                        hex_chars[k & 0xF],
-                    };
+            '`' => {
+                if (quote_char == '`') {
+                    try writer.writeAll("\\`");
                 } else {
-                    bytes.ensureUnusedCapacity(12) catch unreachable;
-                    const old = bytes.list.items.len;
-                    bytes.list.items.len += 12;
-
-                    const k = c - 0x10000;
-                    const lo = @as(usize, @intCast(first_high_surrogate + ((k >> 10) & 0x3FF)));
-                    const hi = @as(usize, @intCast(first_low_surrogate + (k & 0x3FF)));
-
-                    bytes.list.items[old .. old + 12][0..12].* = [_]u8{
-                        '\\',
-                        'u',
-                        hex_chars[lo >> 12],
-                        hex_chars[(lo >> 8) & 15],
-                        hex_chars[(lo >> 4) & 15],
-                        hex_chars[lo & 15],
-                        '\\',
-                        'u',
-                        hex_chars[hi >> 12],
-                        hex_chars[(hi >> 8) & 15],
-                        hex_chars[(hi >> 4) & 15],
-                        hex_chars[hi & 15],
-                    };
+                    try writer.writeAll("`");
                 }
+                i += 1;
             },
-        }
-    }
-    bytes.appendChar('"') catch unreachable;
-}
-
-pub fn writeJSONString(input: []const u8, comptime Writer: type, writer: Writer, comptime encoding: strings.Encoding) !void {
-    try writer.writeAll("\"");
-    var text = input;
-    const end = text.ptr + text.len;
-    if (comptime encoding == .utf16) {
-        @compileError("not implemented yet");
-    }
-
-    while (text.ptr != end) {
-        const width = if (comptime encoding == .latin1 or encoding == .ascii)
-            1
-        else
-            strings.wtf8ByteSequenceLengthWithInvalid(text[0]);
-
-        const c: i32 = if (comptime encoding == .utf8)
-            strings.decodeWTF8RuneT(text.ptr[0..4], width, i32, 0)
-        else brk: {
-            const char = text[0];
-            if (char <= 0x7F) {
-                break :brk char;
-            } else break :brk strings.latin1ToCodepointAssumeNotASCII(char, i32);
-        };
-        if (canPrintWithoutEscape(i32, c, false)) {
-            const remain = text[width..];
-            if (encoding != .utf8 and width > 0) {
-                var codepoint_bytes: [4]u8 = undefined;
-                std.mem.writeInt(i32, &codepoint_bytes, c, .little);
-                try writer.writeAll(
-                    codepoint_bytes[0..strings.encodeWTF8Rune(codepoint_bytes[0..4], c)],
-                );
-            } else if (encoding == .utf8) {
-                try writer.writeAll(text[0..width]);
-            }
-
-            if (strings.indexOfNeedsEscape(remain)) |j| {
-                try writer.writeAll(remain[0..j]);
-                text = remain[j..];
-                continue;
-            } else {
-                try writer.writeAll(remain);
-                break;
-            }
-        }
-        switch (c) {
-            // Special-case the bell character since it may cause dumping this file to
-            // the terminal to make a sound, which is undesirable. Note that we can't
-            // use an octal literal to print this shorter since octal literals are not
-            // allowed in strict mode (or in template strings).
-            0x07 => {
-                try writer.writeAll("\\x07");
-                text = text[1..];
-            },
-            0x08 => {
-                try writer.writeAll("\\b");
-                text = text[1..];
-            },
-            0x0C => {
-                try writer.writeAll("\\f");
-                text = text[1..];
-            },
-            '\n' => {
-                try writer.writeAll("\\n");
-                text = text[1..];
-            },
-            std.ascii.control_code.cr => {
-                try writer.writeAll("\\r");
-                text = text[1..];
-            },
-            // \v
-            std.ascii.control_code.vt => {
-                try writer.writeAll("\\v");
-                text = text[1..];
-            },
-            // "\\"
-            '\\' => {
-                try writer.writeAll("\\\\");
-                text = text[1..];
-            },
-            '"' => {
-                try writer.writeAll("\\\"");
-                text = text[1..];
+            '$' => {
+                if (quote_char == '`') {
+                    const remain = text[i + clamped_width ..];
+                    if (remain.len > 0 and remain[0] == '{') {
+                        try writer.writeAll("\\$");
+                    } else {
+                        try writer.writeAll("$");
+                    }
+                } else {
+                    try writer.writeAll("$");
+                }
+                i += 1;
             },
 
             '\t' => {
                 try writer.writeAll("\\t");
-                text = text[1..];
+                i += 1;
             },
 
             else => {
-                text = text[@as(usize, width)..];
+                i += @as(usize, width);
 
-                if (c < 0xFFFF) {
+                if (c < 0xFF and !json) {
+                    const k = @as(usize, @intCast(c));
+
+                    try writer.writeAll(&[_]u8{
+                        '\\',
+                        'x',
+                        hex_chars[(k >> 4) & 0xF],
+                        hex_chars[k & 0xF],
+                    });
+                } else if (c < 0xFFFF) {
                     const k = @as(usize, @intCast(c));
 
                     try writer.writeAll(&[_]u8{
@@ -461,6 +395,19 @@ pub fn writeJSONString(input: []const u8, comptime Writer: type, writer: Writer,
             },
         }
     }
+}
+pub fn quoteForJSONBuffer(text: []const u8, bytes: *MutableString, comptime ascii_only: bool) !void {
+    const writer = bytes.writer();
+
+    try bytes.growIfNeeded(estimateLengthForUTF8(text, ascii_only, '"'));
+    try bytes.appendChar('"');
+    try writePreQuotedString(text, @TypeOf(writer), writer, '"', ascii_only, true, .utf8);
+    bytes.appendChar('"') catch unreachable;
+}
+
+pub fn writeJSONString(input: []const u8, comptime Writer: type, writer: Writer, comptime encoding: strings.Encoding) !void {
+    try writer.writeAll("\"");
+    try writePreQuotedString(input, Writer, writer, '"', false, true, encoding);
     try writer.writeAll("\"");
 }
 
@@ -1427,7 +1374,7 @@ fn NewPrinter(
                 p.printSpaceBeforeIdentifier();
                 p.printIdentifier(alias);
             } else {
-                p.printQuotedUTF8(alias, false);
+                p.printStringLiteralUTF8(alias, false);
             }
         }
 
@@ -1641,228 +1588,25 @@ fn NewPrinter(
             p.fmt("{d}", .{float}) catch {};
         }
 
-        pub fn printQuotedUTF16(e: *Printer, text: []const u16, quote: u8) void {
-            var i: usize = 0;
-            const n: usize = text.len;
-
-            outer: while (i < n) {
-                const CodeUnitType = u32;
-
-                const c: CodeUnitType = text[i];
-                i += 1;
-
-                switch (c) {
-
-                    // Special-case the null character since it may mess with code written in C
-                    // that treats null characters as the end of the string.
-                    0x00 => {
-                        // We don't want "\x001" to be written as "\01"
-                        if (i < n and text[i] >= '0' and text[i] <= '9') {
-                            e.print("\\x00");
-                        } else {
-                            e.print("\\0");
-                        }
-                    },
-
-                    // Special-case the bell character since it may cause dumping this file to
-                    // the terminal to make a sound, which is undesirable. Note that we can't
-                    // use an octal literal to print this shorter since octal literals are not
-                    // allowed in strict mode (or in template strings).
-                    0x07 => {
-                        e.print("\\x07");
-                    },
-                    0x08 => {
-                        if (quote == '`')
-                            e.print(0x08)
-                        else
-                            e.print("\\b");
-                    },
-                    0x0C => {
-                        if (quote == '`')
-                            e.print(0x000C)
-                        else
-                            e.print("\\f");
-                    },
-                    '\t' => {
-                        if (quote == '`')
-                            e.print("\t")
-                        else
-                            e.print("\\t");
-                    },
-                    '\n' => {
-                        if (quote == '`') {
-                            e.print('\n');
-                        } else {
-                            e.print("\\n");
-                        }
-                    },
-                    // we never print \r un-escaped
-                    std.ascii.control_code.cr => {
-                        e.print("\\r");
-                    },
-                    // \v
-                    std.ascii.control_code.vt => {
-                        if (quote == '`') {
-                            e.print(std.ascii.control_code.vt);
-                        } else {
-                            e.print("\\v");
-                        }
-                    },
-                    // "\\"
-                    '\\' => {
-                        e.print("\\\\");
-                    },
-
-                    '\'' => {
-                        if (quote == '\'') {
-                            e.print('\\');
-                        }
-                        e.print("'");
-                    },
-
-                    '"' => {
-                        if (quote == '"') {
-                            e.print('\\');
-                        }
-
-                        e.print("\"");
-                    },
-                    '`' => {
-                        if (quote == '`') {
-                            e.print('\\');
-                        }
-
-                        e.print("`");
-                    },
-                    '$' => {
-                        if (quote == '`' and i < n and text[i] == '{') {
-                            e.print('\\');
-                        }
-
-                        e.print('$');
-                    },
-                    0x2028 => {
-                        e.print("\\u2028");
-                    },
-                    0x2029 => {
-                        e.print("\\u2029");
-                    },
-                    0xFEFF => {
-                        e.print("\\uFEFF");
-                    },
-
-                    else => {
-                        switch (c) {
-                            first_ascii...last_ascii => {
-                                e.print(@as(u8, @intCast(c)));
-
-                                // Fast path for printing long UTF-16 template literals
-                                // this only applies to template literal strings
-                                // but we print a template literal if there is a \n or a \r
-                                // which is often if the string is long and UTF-16
-                                if (quote == '`') {
-                                    const remain = text[i..];
-                                    if (remain.len > 1 and remain[0] < last_ascii and remain[0] > first_ascii and
-                                        remain[0] != '$' and
-                                        remain[0] != '\\' and
-                                        remain[0] != '`')
-                                    {
-                                        if (strings.@"nextUTF16NonASCIIOr$`\\"([]const u16, remain)) |count_| {
-                                            if (count_ == 0)
-                                                unreachable; // conditional above checks this
-
-                                            const len = count_ - 1;
-                                            i += len;
-                                            var ptr = e.writer.reserve(len) catch unreachable;
-                                            const to_copy = ptr[0..len];
-
-                                            strings.copyU16IntoU8(to_copy, []const u16, remain[0..len]);
-                                            e.writer.advance(len);
-                                            continue :outer;
-                                        } else {
-                                            const count = @as(u32, @truncate(remain.len));
-                                            var ptr = e.writer.reserve(count) catch unreachable;
-                                            const to_copy = ptr[0..count];
-                                            strings.copyU16IntoU8(to_copy, []const u16, remain);
-                                            e.writer.advance(count);
-                                            i += count;
-                                        }
-                                    }
-                                }
-                            },
-                            first_high_surrogate...last_high_surrogate => {
-
-                                // Is there a next character?
-
-                                if (i < n) {
-                                    const c2: CodeUnitType = text[i];
-
-                                    if (c2 >= first_low_surrogate and c2 <= last_low_surrogate) {
-                                        i += 1;
-
-                                        // Escape this character if UTF-8 isn't allowed
-                                        if (ascii_only_always_on_unless_minifying) {
-                                            var ptr = e.writer.reserve(12) catch unreachable;
-                                            ptr[0..12].* = [_]u8{
-                                                '\\', 'u', hex_chars[c >> 12],  hex_chars[(c >> 8) & 15],  hex_chars[(c >> 4) & 15],  hex_chars[c & 15],
-                                                '\\', 'u', hex_chars[c2 >> 12], hex_chars[(c2 >> 8) & 15], hex_chars[(c2 >> 4) & 15], hex_chars[c2 & 15],
-                                            };
-                                            e.writer.advance(12);
-
-                                            continue;
-                                            // Otherwise, encode to UTF-8
-                                        }
-
-                                        const r: CodeUnitType = 0x10000 + (((c & 0x03ff) << 10) | (c2 & 0x03ff));
-
-                                        var ptr = e.writer.reserve(4) catch unreachable;
-                                        e.writer.advance(strings.encodeWTF8RuneT(ptr[0..4], CodeUnitType, r));
-                                        continue;
-                                    }
-                                }
-
-                                // Write an unpaired high surrogate
-                                var ptr = e.writer.reserve(6) catch unreachable;
-                                ptr[0..6].* = [_]u8{ '\\', 'u', hex_chars[c >> 12], hex_chars[(c >> 8) & 15], hex_chars[(c >> 4) & 15], hex_chars[c & 15] };
-                                e.writer.advance(6);
-                            },
-                            // Is this an unpaired low surrogate or four-digit hex escape?
-                            first_low_surrogate...last_low_surrogate => {
-                                // Write an unpaired high surrogate
-                                var ptr = e.writer.reserve(6) catch unreachable;
-                                ptr[0..6].* = [_]u8{ '\\', 'u', hex_chars[c >> 12], hex_chars[(c >> 8) & 15], hex_chars[(c >> 4) & 15], hex_chars[c & 15] };
-                                e.writer.advance(6);
-                            },
-                            else => {
-                                if (ascii_only_always_on_unless_minifying) {
-                                    if (c > 0xFF) {
-                                        var ptr = e.writer.reserve(6) catch unreachable;
-                                        // Write an unpaired high surrogate
-                                        ptr[0..6].* = [_]u8{ '\\', 'u', hex_chars[c >> 12], hex_chars[(c >> 8) & 15], hex_chars[(c >> 4) & 15], hex_chars[c & 15] };
-                                        e.writer.advance(6);
-                                    } else {
-                                        // Can this be a two-digit hex escape?
-                                        var ptr = e.writer.reserve(4) catch unreachable;
-                                        ptr[0..4].* = [_]u8{ '\\', 'x', hex_chars[c >> 4], hex_chars[c & 15] };
-                                        e.writer.advance(4);
-                                    }
-                                } else {
-                                    // chars < 255 as two digit hex escape
-                                    if (c <= 0xFF) {
-                                        var ptr = e.writer.reserve(4) catch unreachable;
-                                        ptr[0..4].* = [_]u8{ '\\', 'x', hex_chars[c >> 4], hex_chars[c & 15] };
-                                        e.writer.advance(4);
-                                        continue;
-                                    }
+        pub fn printStringCharactersUTF8(e: *Printer, text: []const u8, quote: u8) void {
+            const writer = e.writer.stdWriter();
+            (switch (quote) {
+                '\'' => writePreQuotedString(text, @TypeOf(writer), writer, '\'', ascii_only, false, .utf8),
+                '"' => writePreQuotedString(text, @TypeOf(writer), writer, '"', ascii_only, false, .utf8),
+                '`' => writePreQuotedString(text, @TypeOf(writer), writer, '`', ascii_only, false, .utf8),
+                else => unreachable,
+            }) catch |err| switch (err) {};
+        }
+        pub fn printStringCharactersUTF16(e: *Printer, text: []const u16, quote: u8) void {
+            const slice = std.mem.sliceAsBytes(text);
 
-                                    var ptr = e.writer.reserve(4) catch return;
-                                    e.writer.advance(strings.encodeWTF8RuneT(ptr[0..4], CodeUnitType, c));
-                                }
-                            },
-                        }
-                    },
-                }
-            }
+            const writer = e.writer.stdWriter();
+            (switch (quote) {
+                '\'' => writePreQuotedString(slice, @TypeOf(writer), writer, '\'', ascii_only, false, .utf16),
+                '"' => writePreQuotedString(slice, @TypeOf(writer), writer, '"', ascii_only, false, .utf16),
+                '`' => writePreQuotedString(slice, @TypeOf(writer), writer, '`', ascii_only, false, .utf16),
+                else => unreachable,
+            }) catch |err| switch (err) {};
         }
 
         pub fn isUnboundEvalIdentifier(p: *Printer, value: Expr) bool {
@@ -1884,9 +1628,9 @@ fn NewPrinter(
         }
 
         pub fn printRequireError(p: *Printer, text: string) void {
-            p.print("(()=>{throw new Error(`Cannot require module ");
-            p.printQuotedUTF8(text, false);
-            p.print("`);})()");
+            p.print("(()=>{throw new Error(\"Cannot require module \"+");
+            p.printStringLiteralUTF8(text, false);
+            p.print(");})()");
         }
 
         pub inline fn importRecord(
@@ -2009,9 +1753,7 @@ fn NewPrinter(
                     p.print(".require(");
                     {
                         const path = input_files[record.source_index.get()].path;
-                        p.print('"');
-                        p.printUTF8StringEscapedQuotes(path.pretty, '"');
-                        p.print('"');
+                        p.printStringLiteralUTF8(path.pretty, false);
                     }
                     p.print(")");
                 } else if (!meta.was_unwrapped_require) {
@@ -2084,9 +1826,7 @@ fn NewPrinter(
                         p.print(".require(");
                     {
                         const path = record.path;
-                        p.print('"');
-                        p.printUTF8StringEscapedQuotes(path.pretty, '"');
-                        p.print('"');
+                        p.printStringLiteralUTF8(path.pretty, false);
                     }
                     p.print(")");
                     return;
@@ -2156,14 +1896,22 @@ fn NewPrinter(
             p.printWhitespacer(ws("/* @__PURE__ */ "));
         }
 
-        pub fn printQuotedUTF8(p: *Printer, str: string, allow_backtick: bool) void {
+        pub fn printStringLiteralEString(p: *Printer, str: *E.String, allow_backtick: bool) void {
+            const quote = bestQuoteCharForEString(str, allow_backtick);
+            p.print(quote);
+            p.printStringCharactersEString(str, quote);
+            p.print(quote);
+        }
+        pub fn printStringLiteralUTF8(p: *Printer, str: string, allow_backtick: bool) void {
+            if (Environment.allow_assert) std.debug.assert(std.unicode.wtf8ValidateSlice(str));
+
             const quote = if (comptime !is_json)
                 bestQuoteCharForString(u8, str, allow_backtick)
             else
                 '"';
 
             p.print(quote);
-            p.print(str);
+            p.printStringCharactersUTF8(str, quote);
             p.print(quote);
         }
 
@@ -2179,9 +1927,10 @@ fn NewPrinter(
             const name = p.renamer.nameForSymbol(item.name.ref.?);
 
             if (comptime as == .import) {
-                p.printClauseAlias(item.alias);
-
-                if (!strings.eql(name, item.alias)) {
+                if (strings.eql(name, item.alias)) {
+                    p.printIdentifier(name);
+                } else {
+                    p.printClauseAlias(item.alias);
                     p.print(" as ");
                     p.addSourceMapping(item.alias_loc);
                     p.printIdentifier(name);
@@ -2208,16 +1957,6 @@ fn NewPrinter(
             }
         }
 
-        pub inline fn canPrintIdentifier(_: *Printer, name: string) bool {
-            if (comptime is_json) return false;
-
-            if (comptime ascii_only or ascii_only_always_on_unless_minifying) {
-                return js_lexer.isLatin1Identifier(string, name);
-            } else {
-                return js_lexer.isIdentifier(name);
-            }
-        }
-
         pub inline fn canPrintIdentifierUTF16(_: *Printer, name: []const u16) bool {
             if (comptime ascii_only or ascii_only_always_on_unless_minifying) {
                 return js_lexer.isLatin1Identifier([]const u16, name);
@@ -2414,12 +2153,12 @@ fn NewPrinter(
                                     p.printSymbol(p.options.commonjs_named_exports_ref);
                                 }
 
-                                if (p.canPrintIdentifier(key)) {
+                                if (js_lexer.isIdentifier(key)) {
                                     p.print(".");
                                     p.print(key);
                                 } else {
                                     p.print("[");
-                                    p.printPossiblyEscapedIdentifierString(key, true);
+                                    p.printStringLiteralUTF8(key, false);
                                     p.print("]");
                                 }
                             } else {
@@ -2602,7 +2341,7 @@ fn NewPrinter(
                     }
 
                     p.print("(");
-                    p.printQuotedUTF8(p.importRecord(e.import_record_index).path.text, true);
+                    p.printStringLiteralUTF8(p.importRecord(e.import_record_index).path.text, true);
                     p.print(")");
 
                     if (wrap) {
@@ -2694,7 +2433,7 @@ fn NewPrinter(
                         flags,
                     );
 
-                    if (p.canPrintIdentifier(e.name)) {
+                    if (js_lexer.isIdentifier(e.name)) {
                         if (isOptionalChain) {
                             p.print("?.");
                         } else {
@@ -2715,10 +2454,7 @@ fn NewPrinter(
                             p.print("[");
                         }
 
-                        p.printPossiblyEscapedIdentifierString(
-                            e.name,
-                            true,
-                        );
+                        p.printStringLiteralUTF8(e.name, false);
 
                         p.print("]");
                     }
@@ -3011,20 +2747,12 @@ fn NewPrinter(
                     // If this was originally a template literal, print it as one as long as we're not minifying
                     if (e.prefer_template and !p.options.minify_syntax) {
                         p.print("`");
-                        p.printStringContent(e, '`');
+                        p.printStringCharactersEString(e, '`');
                         p.print("`");
                         return;
                     }
 
-                    const c = bestQuoteCharForEString(e, true);
-
-                    p.print(c);
-                    p.printStringContent(e, c);
-                    p.print(c);
-                },
-                .e_utf8_string => |e| {
-                    p.addSourceMapping(expr.loc);
-                    quoteForJSONBuffer(e.data, p.writer.getMutableBuffer(), ascii_only) catch bun.outOfMemory();
+                    p.printStringLiteralEString(e, true);
                 },
                 .e_template => |e| {
                     if (e.tag) |tag| {
@@ -3047,7 +2775,7 @@ fn NewPrinter(
                         .cooked => |*cooked| {
                             if (cooked.isPresent()) {
                                 cooked.resolveRopeIfNeeded(p.options.allocator);
-                                p.printStringContent(cooked, '`');
+                                p.printStringCharactersEString(cooked, '`');
                             }
                         },
                     }
@@ -3061,7 +2789,7 @@ fn NewPrinter(
                             .cooked => |*cooked| {
                                 if (cooked.isPresent()) {
                                     cooked.resolveRopeIfNeeded(p.options.allocator);
-                                    p.printStringContent(cooked, '`');
+                                    p.printStringCharactersEString(cooked, '`');
                                 }
                             },
                         }
@@ -3166,7 +2894,7 @@ fn NewPrinter(
                             p.addSourceMapping(expr.loc);
                             p.printSymbol(namespace.namespace_ref);
                             const alias = namespace.alias;
-                            if (p.canPrintIdentifier(alias)) {
+                            if (js_lexer.isIdentifier(alias)) {
                                 p.print(".");
                                 // TODO: addSourceMappingForName
                                 p.printIdentifier(alias);
@@ -3174,7 +2902,7 @@ fn NewPrinter(
                                 p.print("[");
                                 // TODO: addSourceMappingForName
                                 // p.addSourceMappingForName(alias);
-                                p.printPossiblyEscapedIdentifierString(alias, true);
+                                p.printStringLiteralUTF8(alias, false);
                                 p.print("]");
                             }
 
@@ -3355,94 +3083,16 @@ fn NewPrinter(
             }
         }
 
-        pub inline fn printDotThenSuffix(
-            p: *Printer,
-        ) void {
+        pub inline fn printDotThenSuffix(p: *Printer) void {
             p.print(")");
         }
 
         // This assumes the string has already been quoted.
-        pub fn printStringContent(p: *Printer, str: *const E.String, c: u8) void {
+        pub fn printStringCharactersEString(p: *Printer, str: *const E.String, c: u8) void {
             if (!str.isUTF8()) {
-                // its already quoted for us!
-                p.printQuotedUTF16(str.slice16(), c);
+                p.printStringCharactersUTF16(str.slice16(), c);
             } else {
-                p.printUTF8StringEscapedQuotes(str.data, c);
-            }
-        }
-
-        // Add one outer branch so the inner loop does fewer branches
-        pub fn printUTF8StringEscapedQuotes(p: *Printer, str: string, c: u8) void {
-            switch (c) {
-                '`' => _printUTF8StringEscapedQuotes(p, str, '`'),
-                '"' => _printUTF8StringEscapedQuotes(p, str, '"'),
-                '\'' => _printUTF8StringEscapedQuotes(p, str, '\''),
-                else => unreachable,
-            }
-        }
-
-        pub fn _printUTF8StringEscapedQuotes(p: *Printer, str: string, comptime c: u8) void {
-            var utf8 = str;
-            var i: usize = 0;
-            // Walk the string searching for quote characters
-            // Escape any we find
-            // Skip over already-escaped strings
-            var len = utf8.len;
-            while (i < len) {
-                switch (utf8[i]) {
-                    '\\' => i += 2,
-                    '$' => {
-                        if (comptime c == '`') {
-                            p.print(utf8[0..i]);
-                            p.print("\\$");
-                            utf8 = utf8[i + 1 ..];
-                            len = utf8.len;
-                            i = 0;
-                        } else {
-                            i += 1;
-                        }
-                    },
-                    c => {
-                        p.print(utf8[0..i]);
-                        p.print("\\" ++ &[_]u8{c});
-                        utf8 = utf8[i + 1 ..];
-                        len = utf8.len;
-                        i = 0;
-                    },
-
-                    else => i += 1,
-                }
-            }
-            if (utf8.len > 0) {
-                p.print(utf8);
-            }
-        }
-
-        fn printBindingIdentifierName(p: *Printer, name: string, name_loc: logger.Loc) void {
-            p.addSourceMapping(name_loc);
-
-            if (comptime !is_json and ascii_only) {
-                const quote = bestQuoteCharForString(u8, name, false);
-                p.print(quote);
-                p.printQuotedIdentifier(name);
-                p.print(quote);
-            } else {
-                p.printQuotedUTF8(name, false);
-            }
-        }
-
-        fn printPossiblyEscapedIdentifierString(p: *Printer, name: string, allow_backtick: bool) void {
-            if (comptime !ascii_only or is_json) {
-                p.printQuotedUTF8(name, allow_backtick);
-            } else {
-                const quote = if (comptime !is_json)
-                    bestQuoteCharForString(u8, name, allow_backtick)
-                else
-                    '"';
-
-                p.print(quote);
-                p.printQuotedIdentifier(name);
-                p.print(quote);
+                p.printStringCharactersUTF8(str.data, c);
             }
         }
 
@@ -3456,12 +3106,12 @@ fn NewPrinter(
             // that means the namespace alias is empty
             if (namespace.alias.len == 0) return;
 
-            if (p.canPrintIdentifier(namespace.alias)) {
+            if (js_lexer.isIdentifier(namespace.alias)) {
                 p.print(".");
                 p.printIdentifier(namespace.alias);
             } else {
                 p.print("[");
-                p.printPossiblyEscapedIdentifierString(namespace.alias, true);
+                p.printStringLiteralUTF8(namespace.alias, false);
                 p.print("]");
             }
         }
@@ -3687,11 +3337,11 @@ fn NewPrinter(
                         // While each of those property keys are ASCII, a subset of ASCII is valid as the start of an identifier
                         // "=" and ":" are not valid
                         // So we need to check
-                        if (p.canPrintIdentifier(key.data)) {
-                            p.print(key.data);
+                        if (!is_json and js_lexer.isIdentifier(key.data)) {
+                            p.printIdentifier(key.data);
                         } else {
                             allow_shorthand = false;
-                            p.printBindingIdentifierName(key.data, logger.Loc.Empty);
+                            p.printStringLiteralEString(key, false);
                         }
 
                         // Use a shorthand property if the names are the same
@@ -3728,7 +3378,7 @@ fn NewPrinter(
                                 else => {},
                             }
                         }
-                    } else if (p.canPrintIdentifierUTF16(key.slice16())) {
+                    } else if (!is_json and p.canPrintIdentifierUTF16(key.slice16())) {
                         p.printSpaceBeforeIdentifier();
                         p.printIdentifierUTF16(key.slice16()) catch unreachable;
 
@@ -3771,7 +3421,7 @@ fn NewPrinter(
                     } else {
                         const c = bestQuoteCharForString(u16, key.slice16(), false);
                         p.print(c);
-                        p.printQuotedUTF16(key.slice16(), c);
+                        p.printStringCharactersUTF16(key.slice16(), c);
                         p.print(c);
                     }
                 },
@@ -3929,7 +3579,7 @@ fn NewPrinter(
                                             //              ^
                                             // That needs to be:
                                             //          "aria-label": ariaLabel,
-                                            if (p.canPrintIdentifier(str.data)) {
+                                            if (js_lexer.isIdentifier(str.data)) {
                                                 p.printIdentifier(str.data);
 
                                                 // Use a shorthand property if the names are the same
@@ -3943,7 +3593,7 @@ fn NewPrinter(
                                                     else => {},
                                                 }
                                             } else {
-                                                p.printPossiblyEscapedIdentifierString(str.data, false);
+                                                p.printStringLiteralUTF8(str.data, false);
                                             }
                                         } else if (p.canPrintIdentifierUTF16(str.slice16())) {
                                             p.printSpaceBeforeIdentifier();
@@ -4633,9 +4283,9 @@ fn NewPrinter(
                                 },
 
                                 .auto_onimportcss, .facade_onimportcss => {
-                                    p.print("globalThis.document?.dispatchEvent(new CustomEvent(\"onimportcss\", {detail: \"");
-                                    p.print(record.path.text);
-                                    p.print("\"}));\n");
+                                    p.print("globalThis.document?.dispatchEvent(new CustomEvent(\"onimportcss\", {detail: ");
+                                    p.printStringLiteralUTF8(record.path.text, false);
+                                    p.print("}));\n");
 
                                     // If they actually use the code, then we emit a facade that just echos whatever they write
                                     if (s.default_name) |name| {
@@ -4886,7 +4536,7 @@ fn NewPrinter(
 
                     p.printIndent();
                     p.printSpaceBeforeIdentifier();
-                    p.printQuotedUTF8(s.value, false);
+                    p.printStringLiteralUTF8(s.value, false);
                     p.printSemicolonAfterStatement();
                 },
                 .s_break => |s| {
@@ -4957,13 +4607,13 @@ fn NewPrinter(
             const quote = bestQuoteCharForString(u8, import_record.path.text, false);
             if (import_record.print_namespace_in_path and !import_record.path.isFile()) {
                 p.print(quote);
-                p.print(import_record.path.namespace);
+                p.printStringCharactersUTF8(import_record.path.namespace, quote);
                 p.print(":");
-                p.printIdentifier(import_record.path.text);
+                p.printStringCharactersUTF8(import_record.path.text, quote);
                 p.print(quote);
             } else {
                 p.print(quote);
-                p.printIdentifier(import_record.path.text);
+                p.printStringCharactersUTF8(import_record.path.text, quote);
                 p.print(quote);
             }
         }
@@ -5107,7 +4757,7 @@ fn NewPrinter(
             p.print("Object.defineProperty(");
             p.printModuleExportSymbol();
             p.print(",");
-            p.printQuotedUTF8(name, true);
+            p.printStringLiteralUTF8(name, true);
 
             p.printWhitespacer(ws(",{get: () => ("));
             p.printLoadFromBundle(import_record_index);
@@ -5124,7 +4774,7 @@ fn NewPrinter(
             p.print("Object.defineProperty(");
             p.printModuleExportSymbol();
             p.print(",");
-            p.printQuotedUTF8(name, true);
+            p.printStringLiteralUTF8(name, true);
             p.print(",{get: () => ");
             p.printIdentifier(identifier);
             p.print(", enumerable: true, configurable: true})");
@@ -5377,13 +5027,13 @@ fn NewPrinter(
 
         pub fn printIdentifier(p: *Printer, identifier: string) void {
             if (comptime ascii_only) {
-                p.printQuotedIdentifier(identifier);
+                p.printIdentifierAsciiOnly(identifier);
             } else {
                 p.print(identifier);
             }
         }
 
-        fn printQuotedIdentifier(p: *Printer, identifier: string) void {
+        fn printIdentifierAsciiOnly(p: *Printer, identifier: string) void {
             var ascii_start: usize = 0;
             var is_ascii = false;
             var iter = CodepointIterator.init(identifier);
@@ -5612,6 +5262,14 @@ pub fn NewWriter(
             };
         }
 
+        pub fn stdWriter(self: *Self) std.io.Writer(*Self, error{}, stdWriterWrite) {
+            return .{ .context = self };
+        }
+        pub fn stdWriterWrite(self: *Self, bytes: []const u8) error{}!usize {
+            self.print([]const u8, bytes);
+            return bytes.len;
+        }
+
         pub fn isCopyFileRangeSupported() bool {
             return comptime std.meta.hasFn(ContextType, "copyFileRange");
         }
@@ -6335,9 +5993,7 @@ pub fn printWithWriterAndPlatform(
     if (opts.module_type == .internal_bake_dev) {
         printer.indent();
         printer.printIndent();
-        printer.print('"');
-        printer.printUTF8StringEscapedQuotes(source.path.pretty, '"');
-        printer.print('"');
+        printer.printStringLiteralUTF8(source.path.pretty, false);
         printer.printFunc(parts[0].stmts[0].data.s_expr.value.data.e_function.func);
         printer.print(",\n");
     } else {
diff --git a/src/jsc.zig b/src/jsc.zig
index 8e4c8072649ecb..7fa5521390aa17 100644
--- a/src/jsc.zig
+++ b/src/jsc.zig
@@ -35,6 +35,8 @@ pub const API = struct {
     pub const BuildArtifact = @import("./bun.js/api/JSBundler.zig").BuildArtifact;
     pub const JSTranspiler = @import("./bun.js/api/JSTranspiler.zig");
     pub const HTTPServer = @import("./bun.js/api/server.zig").HTTPServer;
+    pub const AnyServer = @import("./bun.js/api/server.zig").AnyServer;
+    pub const SavedRequest = @import("./bun.js/api/server.zig").SavedRequest;
     pub const ServerConfig = @import("./bun.js/api/server.zig").ServerConfig;
     pub const ServerWebSocket = @import("./bun.js/api/server.zig").ServerWebSocket;
     pub const HTTPSServer = @import("./bun.js/api/server.zig").HTTPSServer;
diff --git a/src/json_parser.zig b/src/json_parser.zig
index 4998d86f0e1d2e..4d30b2d09018f2 100644
--- a/src/json_parser.zig
+++ b/src/json_parser.zig
@@ -115,7 +115,6 @@ fn JSONLikeParser(comptime opts: js_lexer.JSONOptions) type {
         opts.ignore_trailing_escape_sequences,
         opts.json_warn_duplicate_keys,
         opts.was_originally_macro,
-        opts.always_decode_escape_sequences,
         opts.guess_indentation,
     );
 }
@@ -128,7 +127,6 @@ fn JSONLikeParser_(
     comptime opts_ignore_trailing_escape_sequences: bool,
     comptime opts_json_warn_duplicate_keys: bool,
     comptime opts_was_originally_macro: bool,
-    comptime opts_always_decode_escape_sequences: bool,
     comptime opts_guess_indentation: bool,
 ) type {
     const opts = js_lexer.JSONOptions{
@@ -139,7 +137,6 @@ fn JSONLikeParser_(
         .ignore_trailing_escape_sequences = opts_ignore_trailing_escape_sequences,
         .json_warn_duplicate_keys = opts_json_warn_duplicate_keys,
         .was_originally_macro = opts_was_originally_macro,
-        .always_decode_escape_sequences = opts_always_decode_escape_sequences,
         .guess_indentation = opts_guess_indentation,
     };
     return struct {
@@ -193,7 +190,7 @@ fn JSONLikeParser_(
                     return newExpr(E.Null{}, loc);
                 },
                 .t_string_literal => {
-                    var str: E.String = p.lexer.toEString();
+                    var str: E.String = try p.lexer.toEString();
                     if (comptime force_utf8) {
                         str.toUTF8(p.allocator) catch unreachable;
                     }
@@ -282,9 +279,9 @@ fn JSONLikeParser_(
                         }
 
                         const str = if (comptime force_utf8)
-                            p.lexer.toUTF8EString()
+                            try p.lexer.toUTF8EString()
                         else
-                            p.lexer.toEString();
+                            try p.lexer.toEString();
 
                         const key_range = p.lexer.range();
                         const key = newExpr(str, key_range.loc);
@@ -297,7 +294,7 @@ fn JSONLikeParser_(
 
                             // Warn about duplicate keys
                             if (duplicate_get_or_put.found_existing) {
-                                p.log.addRangeWarningFmt(p.source(), key_range, p.allocator, "Duplicate key \"{s}\" in object literal", .{p.lexer.string_literal_slice}) catch unreachable;
+                                p.log.addRangeWarningFmt(p.source(), key_range, p.allocator, "Duplicate key \"{s}\" in object literal", .{try str.string(p.allocator)}) catch unreachable;
                             }
                         }
 
@@ -419,7 +416,7 @@ pub const PackageJSONVersionChecker = struct {
                 return newExpr(E.Null{}, loc);
             },
             .t_string_literal => {
-                const str: E.String = p.lexer.toEString();
+                const str: E.String = try p.lexer.toEString();
 
                 try p.lexer.next();
                 return newExpr(str, loc);
@@ -466,7 +463,7 @@ pub const PackageJSONVersionChecker = struct {
                         }
                     }
 
-                    const str = p.lexer.toEString();
+                    const str = try p.lexer.toEString();
                     const key_range = p.lexer.range();
 
                     const key = newExpr(str, key_range.loc);
@@ -770,7 +767,6 @@ pub fn parsePackageJSONUTF8(
 
     var parser = try JSONLikeParser(.{
         .is_json = true,
-        .always_decode_escape_sequences = false,
         .allow_comments = true,
         .allow_trailing_commas = true,
     }).init(allocator, source.*, log);
@@ -806,7 +802,6 @@ pub fn parsePackageJSONUTF8AlwaysDecode(
 
     var parser = try JSONLikeParser(.{
         .is_json = true,
-        .always_decode_escape_sequences = true,
         .allow_comments = true,
         .allow_trailing_commas = true,
     }).init(allocator, source.*, log);
diff --git a/src/logger.zig b/src/logger.zig
index c1b81145fe191c..d3ff0999cacd66 100644
--- a/src/logger.zig
+++ b/src/logger.zig
@@ -658,8 +658,7 @@ pub const Log = struct {
             }
 
             if (!value.isString()) {
-                globalThis.throwInvalidArguments("Expected logLevel to be a string", .{});
-                return error.JSError;
+                return globalThis.throwInvalidArguments2("Expected logLevel to be a string", .{});
             }
 
             return Map.fromJS(globalThis, value);
diff --git a/src/napi/napi.zig b/src/napi/napi.zig
index 8f25ae51599059..e2b5dd3e579cea 100644
--- a/src/napi/napi.zig
+++ b/src/napi/napi.zig
@@ -67,8 +67,8 @@ pub const Ref = opaque {
 pub const NapiHandleScope = opaque {
     pub extern fn NapiHandleScope__open(globalObject: *JSC.JSGlobalObject, escapable: bool) ?*NapiHandleScope;
     pub extern fn NapiHandleScope__close(globalObject: *JSC.JSGlobalObject, current: ?*NapiHandleScope) void;
-    extern fn NapiHandleScope__append(globalObject: *JSC.JSGlobalObject, value: JSC.JSValueReprInt) void;
-    extern fn NapiHandleScope__escape(handleScope: *NapiHandleScope, value: JSC.JSValueReprInt) bool;
+    extern fn NapiHandleScope__append(globalObject: *JSC.JSGlobalObject, value: JSValue) void;
+    extern fn NapiHandleScope__escape(handleScope: *NapiHandleScope, value: JSValue) bool;
 
     /// Create a new handle scope in the given environment, or return null if creating one now is
     /// unsafe (i.e. inside a finalizer)
@@ -86,14 +86,14 @@ pub const NapiHandleScope = opaque {
     /// callbacks, as the value must remain alive as long as the handle scope is active, even if the
     /// native module doesn't keep it visible on the stack.
     pub fn append(env: napi_env, value: JSC.JSValue) void {
-        NapiHandleScope__append(env, @intFromEnum(value));
+        NapiHandleScope__append(env, value);
     }
 
     /// Move a value from the current handle scope (which must be escapable) to the reserved escape
     /// slot in the parent handle scope, allowing that value to outlive the current handle scope.
     /// Returns an error if escape() has already been called on this handle scope.
     pub fn escape(self: *NapiHandleScope, value: JSC.JSValue) error{EscapeCalledTwice}!void {
-        if (!NapiHandleScope__escape(self, @intFromEnum(value))) {
+        if (!NapiHandleScope__escape(self, value)) {
             return error.EscapeCalledTwice;
         }
     }
@@ -106,7 +106,7 @@ pub const napi_deferred = *JSC.JSPromise.Strong;
 
 /// To ensure napi_values are not collected prematurely after being returned into a native module,
 /// you must use these functions rather than convert between napi_value and JSC.JSValue directly
-pub const napi_value = enum(JSC.JSValueReprInt) {
+pub const napi_value = enum(i64) {
     _,
 
     pub fn set(
@@ -128,16 +128,7 @@ pub const napi_value = enum(JSC.JSValueReprInt) {
     }
 };
 
-pub const struct_napi_escapable_handle_scope__ = opaque {};
-
 const char16_t = u16;
-pub const napi_default: c_int = 0;
-pub const napi_writable: c_int = 1;
-pub const napi_enumerable: c_int = 2;
-pub const napi_configurable: c_int = 4;
-pub const napi_static: c_int = 1024;
-pub const napi_default_method: c_int = 5;
-pub const napi_default_jsproperty: c_int = 7;
 pub const napi_property_attributes = c_uint;
 pub const napi_valuetype = enum(c_uint) {
     undefined = 0,
@@ -245,20 +236,11 @@ pub const napi_extended_error_info = extern struct {
     engine_error_code: u32,
     error_code: napi_status,
 };
-pub const napi_key_include_prototypes: c_int = 0;
-pub const napi_key_own_only: c_int = 1;
-pub const napi_key_collection_mode = c_uint;
-pub const napi_key_all_properties: c_int = 0;
-pub const napi_key_writable: c_int = 1;
-pub const napi_key_enumerable: c_int = 2;
-pub const napi_key_configurable: c_int = 4;
-pub const napi_key_skip_strings: c_int = 8;
-pub const napi_key_skip_symbols: c_int = 16;
-pub const napi_key_filter = c_uint;
-pub const napi_key_keep_numbers: c_int = 0;
-pub const napi_key_numbers_to_strings: c_int = 1;
-pub const napi_key_conversion = c_uint;
-pub const napi_type_tag = extern struct {
+
+const napi_key_collection_mode = c_uint;
+const napi_key_filter = c_uint;
+const napi_key_conversion = c_uint;
+const napi_type_tag = extern struct {
     lower: u64,
     upper: u64,
 };
@@ -617,7 +599,7 @@ pub export fn napi_set_element(env: napi_env, object_: napi_value, index: c_uint
     if (!object.jsType().isIndexable()) {
         return .array_expected;
     }
-    if (value.isEmpty())
+    if (value == .zero)
         return invalidArg();
     JSC.C.JSObjectSetPropertyAtIndex(env.ref(), object.asObjectRef(), index, value.asObjectRef(), TODO_EXCEPTION);
     return .ok;
@@ -1004,7 +986,7 @@ pub export fn napi_is_promise(_: napi_env, value_: napi_value, is_promise_: ?*bo
         return invalidArg();
     };
 
-    if (value.isEmpty()) {
+    if (value == .zero) {
         return invalidArg();
     }
 
@@ -1736,11 +1718,9 @@ pub export fn napi_remove_async_cleanup_hook(_: napi_async_cleanup_hook_handle)
     return .ok;
 }
 
-pub const NAPI_VERSION_EXPERIMENTAL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal);
-pub const NAPI_VERSION = @as(c_int, 8);
-pub const NAPI_AUTO_LENGTH = std.math.maxInt(usize);
-pub const SRC_NODE_API_TYPES_H_ = "";
-pub const NAPI_MODULE_VERSION = @as(c_int, 1);
+const NAPI_VERSION = @as(c_int, 8);
+const NAPI_AUTO_LENGTH = std.math.maxInt(usize);
+const NAPI_MODULE_VERSION = @as(c_int, 1);
 
 /// v8:: C++ symbols defined in v8.cpp
 ///
@@ -1885,13 +1865,156 @@ const V8API = if (!bun.Environment.isWindows) struct {
     pub extern fn @"?IsFunction@Value@v8@@QEBA_NXZ"() *anyopaque;
 };
 
+// To update this list, use find + multi-cursor in your editor.
+// - pub extern fn napi_
+// - pub export fn napi_
+const napi_functions_to_export = .{
+    napi_acquire_threadsafe_function,
+    napi_add_async_cleanup_hook,
+    napi_add_env_cleanup_hook,
+    napi_add_finalizer,
+    napi_adjust_external_memory,
+    napi_async_destroy,
+    napi_async_init,
+    napi_call_function,
+    napi_call_threadsafe_function,
+    napi_cancel_async_work,
+    napi_check_object_type_tag,
+    napi_close_callback_scope,
+    napi_close_escapable_handle_scope,
+    napi_close_handle_scope,
+    napi_coerce_to_bool,
+    napi_coerce_to_number,
+    napi_coerce_to_object,
+    napi_create_array,
+    napi_create_array_with_length,
+    napi_create_arraybuffer,
+    napi_create_async_work,
+    napi_create_bigint_int64,
+    napi_create_bigint_uint64,
+    napi_create_bigint_words,
+    napi_create_buffer,
+    napi_create_buffer_copy,
+    napi_create_dataview,
+    napi_create_date,
+    napi_create_double,
+    napi_create_error,
+    napi_create_external,
+    napi_create_external_arraybuffer,
+    napi_create_external_buffer,
+    napi_create_int32,
+    napi_create_int64,
+    napi_create_object,
+    napi_create_promise,
+    napi_create_range_error,
+    napi_create_reference,
+    napi_create_string_latin1,
+    napi_create_string_utf16,
+    napi_create_string_utf8,
+    napi_create_symbol,
+    napi_create_threadsafe_function,
+    napi_create_type_error,
+    napi_create_typedarray,
+    napi_create_uint32,
+    napi_define_class,
+    napi_define_properties,
+    napi_delete_async_work,
+    napi_delete_element,
+    napi_delete_reference,
+    napi_detach_arraybuffer,
+    napi_escape_handle,
+    napi_fatal_error,
+    napi_fatal_exception,
+    napi_get_all_property_names,
+    napi_get_and_clear_last_exception,
+    napi_get_array_length,
+    napi_get_arraybuffer_info,
+    napi_get_boolean,
+    napi_get_buffer_info,
+    napi_get_cb_info,
+    napi_get_dataview_info,
+    napi_get_date_value,
+    napi_get_element,
+    napi_get_global,
+    napi_get_instance_data,
+    napi_get_last_error_info,
+    napi_get_new_target,
+    napi_get_node_version,
+    napi_get_null,
+    napi_get_prototype,
+    napi_get_reference_value,
+    napi_get_reference_value_internal,
+    napi_get_threadsafe_function_context,
+    napi_get_typedarray_info,
+    napi_get_undefined,
+    napi_get_uv_event_loop,
+    napi_get_value_bigint_int64,
+    napi_get_value_bigint_uint64,
+    napi_get_value_bigint_words,
+    napi_get_value_bool,
+    napi_get_value_double,
+    napi_get_value_external,
+    napi_get_value_int32,
+    napi_get_value_int64,
+    napi_get_value_string_latin1,
+    napi_get_value_string_utf16,
+    napi_get_value_string_utf8,
+    napi_get_value_uint32,
+    napi_get_version,
+    napi_has_element,
+    napi_instanceof,
+    napi_is_array,
+    napi_is_arraybuffer,
+    napi_is_buffer,
+    napi_is_dataview,
+    napi_is_date,
+    napi_is_detached_arraybuffer,
+    napi_is_error,
+    napi_is_exception_pending,
+    napi_is_promise,
+    napi_is_typedarray,
+    napi_make_callback,
+    napi_new_instance,
+    napi_open_callback_scope,
+    napi_open_escapable_handle_scope,
+    napi_open_handle_scope,
+    napi_queue_async_work,
+    napi_ref_threadsafe_function,
+    napi_reference_ref,
+    napi_reference_unref,
+    napi_reject_deferred,
+    napi_release_threadsafe_function,
+    napi_remove_async_cleanup_hook,
+    napi_remove_env_cleanup_hook,
+    napi_remove_wrap,
+    napi_resolve_deferred,
+    napi_run_script,
+    napi_set_element,
+    napi_set_instance_data,
+    napi_strict_equals,
+    napi_throw,
+    napi_throw_error,
+    napi_throw_range_error,
+    napi_throw_type_error,
+    napi_type_tag_object,
+    napi_typeof,
+    napi_unref_threadsafe_function,
+    napi_unwrap,
+    napi_wrap,
+
+    // -- node-api
+    node_api_create_syntax_error,
+    node_api_symbol_for,
+    node_api_throw_syntax_error,
+    node_api_create_external_string_latin1,
+    node_api_create_external_string_utf16,
+};
+
 pub fn fixDeadCodeElimination() void {
     JSC.markBinding(@src());
 
-    inline for (comptime std.meta.declarations(@This())) |decl| {
-        if (std.mem.startsWith(u8, decl.name, "node_api_") or std.mem.startsWith(u8, decl.name, "napi_")) {
-            std.mem.doNotOptimizeAway(&@field(@This(), decl.name));
-        }
+    inline for (napi_functions_to_export) |fn_name| {
+        std.mem.doNotOptimizeAway(&fn_name);
     }
 
     inline for (comptime std.meta.declarations(V8API)) |decl| {
diff --git a/src/options.zig b/src/options.zig
index 612977988a18ed..c091601d8b04ee 100644
--- a/src/options.zig
+++ b/src/options.zig
@@ -395,11 +395,9 @@ pub const Target = enum {
         .{ "node", .node },
     });
 
-    pub fn fromJS(global: *JSC.JSGlobalObject, value: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Target {
-        if (!value.jsType().isStringLike()) {
-            JSC.throwInvalidArguments("target must be a string", .{}, global, exception);
-
-            return null;
+    pub fn fromJS(global: *JSC.JSGlobalObject, value: JSC.JSValue) bun.JSError!?Target {
+        if (!value.isString()) {
+            return global.throwInvalidArguments2("target must be a string", .{});
         }
         return Map.fromJS(global, value);
     }
@@ -612,17 +610,15 @@ pub const Format = enum {
         .{ "internal_bake_dev", .internal_bake_dev },
     });
 
-    pub fn fromJS(global: *JSC.JSGlobalObject, format: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Format {
+    pub fn fromJS(global: *JSC.JSGlobalObject, format: JSC.JSValue) bun.JSError!?Format {
         if (format.isUndefinedOrNull()) return null;
 
-        if (!format.jsType().isStringLike()) {
-            JSC.throwInvalidArguments("format must be a string", .{}, global, exception);
-            return null;
+        if (!format.isString()) {
+            return global.throwInvalidArguments2("format must be a string", .{});
         }
 
         return Map.fromJS(global, format) orelse {
-            JSC.throwInvalidArguments("Invalid format - must be esm, cjs, or iife", .{}, global, exception);
-            return null;
+            return global.throwInvalidArguments2("Invalid format - must be esm, cjs, or iife", .{});
         };
     }
 
@@ -660,7 +656,6 @@ pub const Loader = enum(u8) {
         if (experimental_css) {
             return switch (this) {
                 .file,
-                .css,
                 .napi,
                 .sqlite,
                 .sqlite_embedded,
@@ -731,12 +726,11 @@ pub const Loader = enum(u8) {
         return stdin_name.get(this);
     }
 
-    pub fn fromJS(global: *JSC.JSGlobalObject, loader: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Loader {
+    pub fn fromJS(global: *JSC.JSGlobalObject, loader: JSC.JSValue) bun.JSError!?Loader {
         if (loader.isUndefinedOrNull()) return null;
 
-        if (!loader.jsType().isStringLike()) {
-            JSC.throwInvalidArguments("loader must be a string", .{}, global, exception);
-            return null;
+        if (!loader.isString()) {
+            return global.throwInvalidArguments2("loader must be a string", .{});
         }
 
         var zig_str = JSC.ZigString.init("");
@@ -744,8 +738,7 @@ pub const Loader = enum(u8) {
         if (zig_str.len == 0) return null;
 
         return fromString(zig_str.slice()) orelse {
-            JSC.throwInvalidArguments("invalid loader - must be js, jsx, tsx, ts, css, file, toml, wasm, bunsh, or json", .{}, global, exception);
-            return null;
+            return global.throwInvalidArguments2("invalid loader - must be js, jsx, tsx, ts, css, file, toml, wasm, bunsh, or json", .{});
         };
     }
 
diff --git a/src/output.zig b/src/output.zig
index 1812e29efbf939..0a358bb1bc08b5 100644
--- a/src/output.zig
+++ b/src/output.zig
@@ -704,13 +704,25 @@ pub noinline fn print(comptime fmt: string, args: anytype) callconv(std.builtin.
 /// To enable all logs, set the environment variable
 ///   BUN_DEBUG_ALL=1
 pub const LogFunction = fn (comptime fmt: string, args: anytype) callconv(bun.callconv_inline) void;
+
 pub fn Scoped(comptime tag: anytype, comptime disabled: bool) type {
-    const tagname = switch (@TypeOf(tag)) {
-        @Type(.EnumLiteral) => @tagName(tag),
-        else => tag,
+    const tagname = comptime brk: {
+        const input = switch (@TypeOf(tag)) {
+            @Type(.EnumLiteral) => @tagName(tag),
+            else => tag,
+        };
+        var ascii_slice: [input.len]u8 = undefined;
+        for (input, &ascii_slice) |in, *out| {
+            out.* = std.ascii.toLower(in);
+        }
+        break :brk ascii_slice;
     };
 
-    if (comptime !Environment.isDebug and !Environment.enable_logs) {
+    return ScopedLogger(&tagname, disabled);
+}
+
+fn ScopedLogger(comptime tagname: []const u8, comptime disabled: bool) type {
+    if (comptime !Environment.enable_logs) {
         return struct {
             pub inline fn isVisible() bool {
                 return false;
@@ -732,12 +744,22 @@ pub fn Scoped(comptime tag: anytype, comptime disabled: bool) type {
         pub fn isVisible() bool {
             if (!evaluated_disable) {
                 evaluated_disable = true;
-                if (bun.getenvZ("BUN_DEBUG_" ++ tagname)) |val| {
+                if (bun.getenvZAnyCase("BUN_DEBUG_" ++ tagname)) |val| {
                     really_disable = strings.eqlComptime(val, "0");
-                } else if (bun.getenvZ("BUN_DEBUG_ALL")) |val| {
+                } else if (bun.getenvZAnyCase("BUN_DEBUG_ALL")) |val| {
                     really_disable = strings.eqlComptime(val, "0");
-                } else if (bun.getenvZ("BUN_DEBUG_QUIET_LOGS")) |val| {
+                } else if (bun.getenvZAnyCase("BUN_DEBUG_QUIET_LOGS")) |val| {
                     really_disable = really_disable or !strings.eqlComptime(val, "0");
+                } else {
+                    for (bun.argv) |arg| {
+                        if (strings.eqlCaseInsensitiveASCII(arg, comptime "--debug-" ++ tagname, true)) {
+                            really_disable = false;
+                            break;
+                        } else if (strings.eqlCaseInsensitiveASCII(arg, comptime "--debug-all", true)) {
+                            really_disable = false;
+                            break;
+                        }
+                    }
                 }
             }
             return !really_disable;
@@ -803,7 +825,10 @@ pub fn Scoped(comptime tag: anytype, comptime disabled: bool) type {
 }
 
 pub fn scoped(comptime tag: anytype, comptime disabled: bool) LogFunction {
-    return Scoped(tag, disabled).log;
+    return Scoped(
+        tag,
+        disabled,
+    ).log;
 }
 
 // Valid "colors":
diff --git a/src/patch.zig b/src/patch.zig
index be170ab0840a22..718629f8e5e34a 100644
--- a/src/patch.zig
+++ b/src/patch.zig
@@ -1094,7 +1094,7 @@ const PatchLinesParser = struct {
 };
 
 pub const TestingAPIs = struct {
-    pub fn makeDiff(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn makeDiff(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments_ = callframe.arguments(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
 
@@ -1146,7 +1146,7 @@ pub const TestingAPIs = struct {
             }
         }
     };
-    pub fn apply(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn apply(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         var args = switch (parseApplyArgs(globalThis, callframe)) {
             .err => |e| return e,
             .result => |a| a,
@@ -1161,7 +1161,7 @@ pub const TestingAPIs = struct {
         return .true;
     }
     /// Used in JS tests, see `internal-for-testing.ts` and patch tests.
-    pub fn parse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn parse(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments_ = callframe.arguments(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
 
diff --git a/src/resolver/resolver.zig b/src/resolver/resolver.zig
index 438d16b9b69f30..6a9bce7f70fe80 100644
--- a/src/resolver/resolver.zig
+++ b/src/resolver/resolver.zig
@@ -1774,7 +1774,7 @@ pub const Resolver = struct {
             load_module_from_cache: {
                 // If the source directory doesn't have a node_modules directory, we can
                 // check the global cache directory for a package.json file.
-                var manager = r.getPackageManager();
+                const manager = r.getPackageManager();
                 var dependency_version = Dependency.Version{};
                 var dependency_behavior = Dependency.Behavior.normal;
                 var string_buf = esm.version;
@@ -2483,25 +2483,15 @@ pub const Resolver = struct {
         return PackageJSON.new(pkg);
     }
 
-    fn dirInfoCached(
-        r: *ThisResolver,
-        path: string,
-    ) !?*DirInfo {
+    fn dirInfoCached(r: *ThisResolver, path: string) !?*DirInfo {
         return try r.dirInfoCachedMaybeLog(path, true, true);
     }
 
-    /// The path must have a trailing slash and a sentinel 0
-    pub fn readDirInfo(
-        r: *ThisResolver,
-        path: string,
-    ) !?*DirInfo {
+    pub fn readDirInfo(r: *ThisResolver, path: string) !?*DirInfo {
         return try r.dirInfoCachedMaybeLog(path, false, true);
     }
 
-    pub fn readDirInfoIgnoreError(
-        r: *ThisResolver,
-        path: string,
-    ) ?*const DirInfo {
+    pub fn readDirInfoIgnoreError(r: *ThisResolver, path: string) ?*const DirInfo {
         return r.dirInfoCachedMaybeLog(path, false, true) catch null;
     }
 
@@ -3280,11 +3270,15 @@ pub const Resolver = struct {
         };
     }
 
-    pub export fn Resolver__nodeModulePathsForJS(globalThis: *bun.JSC.JSGlobalObject, callframe: *bun.JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    comptime {
+        const Resolver__nodeModulePathsForJS = JSC.toJSHostFunction(Resolver__nodeModulePathsForJS_);
+        @export(Resolver__nodeModulePathsForJS, .{ .name = "Resolver__nodeModulePathsForJS" });
+    }
+    pub fn Resolver__nodeModulePathsForJS_(globalThis: *bun.JSC.JSGlobalObject, callframe: *bun.JSC.CallFrame) bun.JSError!JSC.JSValue {
         bun.JSC.markBinding(@src());
         const argument: bun.JSC.JSValue = callframe.argument(0);
 
-        if (argument.isEmpty() or !argument.isString()) {
+        if (argument == .zero or !argument.isString()) {
             globalThis.throwInvalidArgumentType("nodeModulePaths", "path", "string");
             return .zero;
         }
@@ -4204,7 +4198,6 @@ pub const GlobalCache = enum {
 
 comptime {
     if (!bun.JSC.is_bindgen) {
-        _ = Resolver.Resolver__nodeModulePathsForJS;
         _ = Resolver.Resolver__propForRequireMainPaths;
     }
 }
diff --git a/src/shell/interpreter.zig b/src/shell/interpreter.zig
index d3b7c64366be74..249bb6dfd80408 100644
--- a/src/shell/interpreter.zig
+++ b/src/shell/interpreter.zig
@@ -703,7 +703,7 @@ pub const ParsedShellScript = struct {
         bun.destroy(this);
     }
 
-    pub fn setCwd(this: *ParsedShellScript, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setCwd(this: *ParsedShellScript, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const arguments_ = callframe.arguments(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const str_js = arguments.nextEat() orelse {
@@ -715,13 +715,13 @@ pub const ParsedShellScript = struct {
         return .undefined;
     }
 
-    pub fn setQuiet(this: *ParsedShellScript, _: *JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn setQuiet(this: *ParsedShellScript, _: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         log("Interpreter(0x{x}) setQuiet()", .{@intFromPtr(this)});
         this.quiet = true;
         return .undefined;
     }
 
-    pub fn setEnv(this: *ParsedShellScript, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setEnv(this: *ParsedShellScript, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         var env =
             if (this.export_env) |*env|
         brk: {
@@ -765,17 +765,13 @@ pub const ParsedShellScript = struct {
         return .undefined;
     }
 
-    pub fn createParsedShellScript(
-        globalThis: *JSC.JSGlobalObject,
-        callframe: *JSC.CallFrame,
-    ) JSValue {
+    pub fn createParsedShellScript(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         var shargs = ShellArgs.init();
 
         const arguments_ = callframe.arguments(2);
         const arguments = arguments_.slice();
         if (arguments.len < 2) {
-            globalThis.throwNotEnoughArguments("Bun.$", 2, arguments.len);
-            return .zero;
+            return globalThis.throwNotEnoughArguments("Bun.$", 2, arguments.len);
         }
         const string_args = arguments[0];
         const template_args_js = arguments[1];
@@ -1188,7 +1184,7 @@ pub const Interpreter = struct {
     pub fn createShellInterpreter(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSValue {
+    ) bun.JSError!JSValue {
         const allocator = bun.default_allocator;
         const arguments_ = callframe.arguments(3);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
@@ -1642,7 +1638,7 @@ pub const Interpreter = struct {
         return Maybe(void).success;
     }
 
-    pub fn runFromJS(this: *ThisInterpreter, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn runFromJS(this: *ThisInterpreter, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         _ = callframe; // autofix
 
         if (this.setupIOBeforeRun().asErr()) |e| {
@@ -1786,13 +1782,13 @@ pub const Interpreter = struct {
         this.allocator.destroy(this);
     }
 
-    pub fn setQuiet(this: *ThisInterpreter, _: *JSGlobalObject, _: *JSC.CallFrame) JSC.JSValue {
+    pub fn setQuiet(this: *ThisInterpreter, _: *JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         log("Interpreter(0x{x}) setQuiet()", .{@intFromPtr(this)});
         this.flags.quiet = true;
         return .undefined;
     }
 
-    pub fn setCwd(this: *ThisInterpreter, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setCwd(this: *ThisInterpreter, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const value = callframe.argument(0);
         const str = bun.String.fromJS(value, globalThis);
 
@@ -1808,7 +1804,7 @@ pub const Interpreter = struct {
         return .undefined;
     }
 
-    pub fn setEnv(this: *ThisInterpreter, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn setEnv(this: *ThisInterpreter, globalThis: *JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const value1 = callframe.argument(0);
         if (!value1.isObject()) {
             globalThis.throwInvalidArguments("env must be an object", .{});
@@ -1849,7 +1845,7 @@ pub const Interpreter = struct {
         this: *ThisInterpreter,
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         _ = globalThis; // autofix
         _ = callframe; // autofix
 
@@ -1860,7 +1856,7 @@ pub const Interpreter = struct {
         this: *ThisInterpreter,
         globalThis: *JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         _ = globalThis; // autofix
         _ = callframe; // autofix
 
diff --git a/src/shell/shell.zig b/src/shell/shell.zig
index afd9782900b4fd..49d28db8408b70 100644
--- a/src/shell/shell.zig
+++ b/src/shell/shell.zig
@@ -3782,7 +3782,7 @@ pub fn handleTemplateValue(
     jsobjref_buf: []u8,
 ) !bool {
     var builder = ShellSrcBuilder.init(globalThis, out_script, jsstrings);
-    if (!template_value.isEmpty()) {
+    if (template_value != .zero) {
         if (template_value.asArrayBuffer(globalThis)) |array_buffer| {
             _ = array_buffer;
             const idx = out_jsobjs.items.len;
@@ -4313,7 +4313,7 @@ pub fn SmolList(comptime T: type, comptime INLINED_MAX: comptime_int) type {
 
 /// Used in JS tests, see `internal-for-testing.ts` and shell tests.
 pub const TestingAPIs = struct {
-    pub fn disabledOnThisPlatform(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSC.JSValue {
+    pub fn disabledOnThisPlatform(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         if (comptime bun.Environment.isWindows) return JSValue.false;
 
         const arguments_ = callframe.arguments(1);
@@ -4339,7 +4339,7 @@ pub const TestingAPIs = struct {
     pub fn shellLex(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments_ = callframe.arguments(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const string_args = arguments.nextEat() orelse {
@@ -4429,7 +4429,7 @@ pub const TestingAPIs = struct {
     pub fn shellParse(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         const arguments_ = callframe.arguments(2);
         var arguments = JSC.Node.ArgumentsSlice.init(globalThis.bunVM(), arguments_.slice());
         const string_args = arguments.nextEat() orelse {
diff --git a/src/sourcemap/sourcemap.zig b/src/sourcemap/sourcemap.zig
index dc5cbdb8ac3e9d..997a41708cbeff 100644
--- a/src/sourcemap/sourcemap.zig
+++ b/src/sourcemap/sourcemap.zig
@@ -179,10 +179,7 @@ pub fn parseJSON(
         if (item.data != .e_string)
             return error.InvalidSourceMap;
 
-        const utf16_decode = try bun.js_lexer.decodeStringLiteralEscapeSequencesToUTF16(item.data.e_string.string(arena) catch bun.outOfMemory(), arena);
-        defer arena.free(utf16_decode);
-        source_paths_slice.?[i] = bun.strings.toUTF8Alloc(alloc, utf16_decode) catch
-            return error.InvalidSourceMap;
+        source_paths_slice.?[i] = try alloc.dupe(u8, try item.data.e_string.string(alloc));
 
         i += 1;
     };
@@ -229,11 +226,7 @@ pub fn parseJSON(
             break :content null;
         }
 
-        const utf16_decode = try bun.js_lexer.decodeStringLiteralEscapeSequencesToUTF16(str, arena);
-        defer arena.free(utf16_decode);
-
-        break :content bun.strings.toUTF8Alloc(alloc, utf16_decode) catch
-            return error.InvalidSourceMap;
+        break :content try alloc.dupe(u8, str);
     } else null;
 
     return .{
diff --git a/src/sql/postgres.zig b/src/sql/postgres.zig
index e51b0e169c95d9..aefdd4c5de117c 100644
--- a/src/sql/postgres.zig
+++ b/src/sql/postgres.zig
@@ -3,15 +3,26 @@ const JSC = bun.JSC;
 const String = bun.String;
 const uws = bun.uws;
 const std = @import("std");
-const debug = bun.Output.scoped(.Postgres, false);
-const int4 = u32;
-const PostgresInt32 = int4;
-const short = u16;
-const PostgresShort = u16;
+pub const debug = bun.Output.scoped(.Postgres, false);
+pub const int4 = u32;
+pub const PostgresInt32 = int4;
+pub const int8 = i64;
+pub const PostgresInt64 = int8;
+pub const short = u16;
+pub const PostgresShort = u16;
 const Crypto = JSC.API.Bun.Crypto;
 const JSValue = JSC.JSValue;
+const BoringSSL = @import("../boringssl.zig");
+
+pub const SSLMode = enum(u8) {
+    disable = 0,
+    prefer = 1,
+    require = 2,
+    verify_ca = 3,
+    verify_full = 4,
+};
 
-const Data = union(enum) {
+pub const Data = union(enum) {
     owned: bun.ByteList,
     temporary: []const u8,
     empty: void,
@@ -72,1913 +83,80 @@ const Data = union(enum) {
         };
     }
 };
+pub const protocol = @import("./postgres/postgres_protocol.zig");
+pub const types = @import("./postgres/postgres_types.zig");
 
-pub const protocol = struct {
-    pub const ArrayList = struct {
-        array: *std.ArrayList(u8),
-
-        pub fn offset(this: @This()) usize {
-            return this.array.items.len;
-        }
-
-        pub fn write(this: @This(), bytes: []const u8) anyerror!void {
-            try this.array.appendSlice(bytes);
-        }
-
-        pub fn pwrite(this: @This(), bytes: []const u8, i: usize) anyerror!void {
-            @memcpy(this.array.items[i..][0..bytes.len], bytes);
-        }
-
-        pub const Writer = NewWriter(@This());
-    };
-
-    pub const StackReader = struct {
-        buffer: []const u8 = "",
-        offset: *usize,
-        message_start: *usize,
-
-        pub fn markMessageStart(this: @This()) void {
-            this.message_start.* = this.offset.*;
-        }
-
-        pub fn ensureLength(this: @This(), length: usize) bool {
-            return this.buffer.len >= (this.offset.* + length);
-        }
-
-        pub fn init(buffer: []const u8, offset: *usize, message_start: *usize) protocol.NewReader(StackReader) {
-            return .{
-                .wrapped = .{
-                    .buffer = buffer,
-                    .offset = offset,
-                    .message_start = message_start,
-                },
-            };
-        }
-
-        pub fn peek(this: StackReader) []const u8 {
-            return this.buffer[this.offset.*..];
-        }
-        pub fn skip(this: StackReader, count: usize) void {
-            if (this.offset.* + count > this.buffer.len) {
-                this.offset.* = this.buffer.len;
-                return;
-            }
-
-            this.offset.* += count;
-        }
-        pub fn ensureCapacity(this: StackReader, count: usize) bool {
-            return this.buffer.len >= (this.offset.* + count);
-        }
-        pub fn read(this: StackReader, count: usize) anyerror!Data {
-            const offset = this.offset.*;
-            if (!this.ensureCapacity(count)) {
-                return error.ShortRead;
-            }
-
-            this.skip(count);
-            return Data{
-                .temporary = this.buffer[offset..this.offset.*],
-            };
-        }
-        pub fn readZ(this: StackReader) anyerror!Data {
-            const remaining = this.peek();
-            if (bun.strings.indexOfChar(remaining, 0)) |zero| {
-                this.skip(zero + 1);
-                return Data{
-                    .temporary = remaining[0..zero],
-                };
-            }
-
-            return error.ShortRead;
-        }
-    };
-
-    pub fn NewWriterWrap(
-        comptime Context: type,
-        comptime offsetFn_: (fn (ctx: Context) usize),
-        comptime writeFunction_: (fn (ctx: Context, bytes: []const u8) anyerror!void),
-        comptime pwriteFunction_: (fn (ctx: Context, bytes: []const u8, offset: usize) anyerror!void),
-    ) type {
-        return struct {
-            wrapped: Context,
-
-            const writeFn = writeFunction_;
-            const pwriteFn = pwriteFunction_;
-            const offsetFn = offsetFn_;
-            pub const Ctx = Context;
-
-            pub const WrappedWriter = @This();
-
-            pub inline fn write(this: @This(), data: []const u8) anyerror!void {
-                try writeFn(this.wrapped, data);
-            }
-
-            pub const LengthWriter = struct {
-                index: usize,
-                context: WrappedWriter,
-
-                pub fn write(this: LengthWriter) anyerror!void {
-                    try this.context.pwrite(&Int32(this.context.offset() - this.index), this.index);
-                }
-
-                pub fn writeExcludingSelf(this: LengthWriter) anyerror!void {
-                    try this.context.pwrite(&Int32(this.context.offset() -| (this.index + 4)), this.index);
-                }
-            };
-
-            pub inline fn length(this: @This()) anyerror!LengthWriter {
-                const i = this.offset();
-                try this.int4(0);
-                return LengthWriter{
-                    .index = i,
-                    .context = this,
-                };
-            }
-
-            pub inline fn offset(this: @This()) usize {
-                return offsetFn(this.wrapped);
-            }
-
-            pub inline fn pwrite(this: @This(), data: []const u8, i: usize) anyerror!void {
-                try pwriteFn(this.wrapped, data, i);
-            }
-
-            pub fn int4(this: @This(), value: PostgresInt32) !void {
-                try this.write(std.mem.asBytes(&@byteSwap(value)));
-            }
-
-            pub fn sint4(this: @This(), value: i32) !void {
-                try this.write(std.mem.asBytes(&@byteSwap(value)));
-            }
-
-            pub fn @"f64"(this: @This(), value: f64) !void {
-                try this.write(std.mem.asBytes(&@byteSwap(@as(u64, @bitCast(value)))));
-            }
-
-            pub fn @"f32"(this: @This(), value: f32) !void {
-                try this.write(std.mem.asBytes(&@byteSwap(@as(u32, @bitCast(value)))));
-            }
-
-            pub fn short(this: @This(), value: anytype) !void {
-                try this.write(std.mem.asBytes(&@byteSwap(@as(u16, @intCast(value)))));
-            }
-
-            pub fn string(this: @This(), value: []const u8) !void {
-                try this.write(value);
-                if (value.len == 0 or value[value.len - 1] != 0)
-                    try this.write(&[_]u8{0});
-            }
-
-            pub fn bytes(this: @This(), value: []const u8) !void {
-                try this.write(value);
-                if (value.len == 0 or value[value.len - 1] != 0)
-                    try this.write(&[_]u8{0});
-            }
-
-            pub fn @"bool"(this: @This(), value: bool) !void {
-                try this.write(if (value) "t" else "f");
-            }
-
-            pub fn @"null"(this: @This()) !void {
-                try this.int4(std.math.maxInt(PostgresInt32));
-            }
-
-            pub fn String(this: @This(), value: bun.String) !void {
-                if (value.isEmpty()) {
-                    try this.write(&[_]u8{0});
-                    return;
-                }
-
-                var sliced = value.toUTF8(bun.default_allocator);
-                defer sliced.deinit();
-                const slice = sliced.slice();
-
-                try this.write(slice);
-                if (slice.len == 0 or slice[slice.len - 1] != 0)
-                    try this.write(&[_]u8{0});
-            }
-        };
-    }
-
-    pub const FieldType = enum(u8) {
-        /// Severity: the field contents are ERROR, FATAL, or PANIC (in an error message), or WARNING, NOTICE, DEBUG, INFO, or LOG (in a notice message), or a localized translation of one of these. Always present.
-        S = 'S',
-
-        /// Severity: the field contents are ERROR, FATAL, or PANIC (in an error message), or WARNING, NOTICE, DEBUG, INFO, or LOG (in a notice message). This is identical to the S field except that the contents are never localized. This is present only in messages generated by PostgreSQL versions 9.6 and later.
-        V = 'V',
-
-        /// Code: the SQLSTATE code for the error (see Appendix A). Not localizable. Always present.
-        C = 'C',
-
-        /// Message: the primary human-readable error message. This should be accurate but terse (typically one line). Always present.
-        M = 'M',
-
-        /// Detail: an optional secondary error message carrying more detail about the problem. Might run to multiple lines.
-        D = 'D',
-
-        /// Hint: an optional suggestion what to do about the problem. This is intended to differ from Detail in that it offers advice (potentially inappropriate) rather than hard facts. Might run to multiple lines.
-        H = 'H',
-
-        /// Position: the field value is a decimal ASCII integer, indicating an error cursor position as an index into the original query string. The first character has index 1, and positions are measured in characters not bytes.
-        P = 'P',
-
-        /// Internal position: this is defined the same as the P field, but it is used when the cursor position refers to an internally generated command rather than the one submitted by the client. The q field will always appear when this field appears.
-        p = 'p',
-
-        /// Internal query: the text of a failed internally-generated command. This could be, for example, an SQL query issued by a PL/pgSQL function.
-        q = 'q',
-
-        /// Where: an indication of the context in which the error occurred. Presently this includes a call stack traceback of active procedural language functions and internally-generated queries. The trace is one entry per line, most recent first.
-        W = 'W',
-
-        /// Schema name: if the error was associated with a specific database object, the name of the schema containing that object, if any.
-        s = 's',
-
-        /// Table name: if the error was associated with a specific table, the name of the table. (Refer to the schema name field for the name of the table's schema.)
-        t = 't',
-
-        /// Column name: if the error was associated with a specific table column, the name of the column. (Refer to the schema and table name fields to identify the table.)
-        c = 'c',
-
-        /// Data type name: if the error was associated with a specific data type, the name of the data type. (Refer to the schema name field for the name of the data type's schema.)
-        d = 'd',
-
-        /// Constraint name: if the error was associated with a specific constraint, the name of the constraint. Refer to fields listed above for the associated table or domain. (For this purpose, indexes are treated as constraints, even if they weren't created with constraint syntax.)
-        n = 'n',
-
-        /// File: the file name of the source-code location where the error was reported.
-        F = 'F',
-
-        /// Line: the line number of the source-code location where the error was reported.
-        L = 'L',
-
-        /// Routine: the name of the source-code routine reporting the error.
-        R = 'R',
-
-        _,
-    };
-
-    pub const FieldMessage = union(FieldType) {
-        S: String,
-        V: String,
-        C: String,
-        M: String,
-        D: String,
-        H: String,
-        P: String,
-        p: String,
-        q: String,
-        W: String,
-        s: String,
-        t: String,
-        c: String,
-        d: String,
-        n: String,
-        F: String,
-        L: String,
-        R: String,
-
-        pub fn format(this: FieldMessage, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-            switch (this) {
-                inline else => |str| {
-                    try std.fmt.format(writer, "{}", .{str});
-                },
-            }
-        }
-
-        pub fn deinit(this: *FieldMessage) void {
-            switch (this.*) {
-                inline else => |*message| {
-                    message.deref();
-                },
-            }
-        }
-
-        pub fn decodeList(comptime Context: type, reader: NewReader(Context)) !std.ArrayListUnmanaged(FieldMessage) {
-            var messages = std.ArrayListUnmanaged(FieldMessage){};
-            while (true) {
-                const field_int = try reader.int(u8);
-                if (field_int == 0) break;
-                const field: FieldType = @enumFromInt(field_int);
-
-                var message = try reader.readZ();
-                defer message.deinit();
-                if (message.slice().len == 0) break;
-
-                try messages.append(bun.default_allocator, FieldMessage.init(field, message.slice()) catch continue);
-            }
-
-            return messages;
-        }
-
-        pub fn init(tag: FieldType, message: []const u8) !FieldMessage {
-            return switch (tag) {
-                .S => FieldMessage{ .S = String.createUTF8(message) },
-                .V => FieldMessage{ .V = String.createUTF8(message) },
-                .C => FieldMessage{ .C = String.createUTF8(message) },
-                .M => FieldMessage{ .M = String.createUTF8(message) },
-                .D => FieldMessage{ .D = String.createUTF8(message) },
-                .H => FieldMessage{ .H = String.createUTF8(message) },
-                .P => FieldMessage{ .P = String.createUTF8(message) },
-                .p => FieldMessage{ .p = String.createUTF8(message) },
-                .q => FieldMessage{ .q = String.createUTF8(message) },
-                .W => FieldMessage{ .W = String.createUTF8(message) },
-                .s => FieldMessage{ .s = String.createUTF8(message) },
-                .t => FieldMessage{ .t = String.createUTF8(message) },
-                .c => FieldMessage{ .c = String.createUTF8(message) },
-                .d => FieldMessage{ .d = String.createUTF8(message) },
-                .n => FieldMessage{ .n = String.createUTF8(message) },
-                .F => FieldMessage{ .F = String.createUTF8(message) },
-                .L => FieldMessage{ .L = String.createUTF8(message) },
-                .R => FieldMessage{ .R = String.createUTF8(message) },
-                else => error.UnknownFieldType,
-            };
-        }
-    };
-
-    pub fn NewReaderWrap(
-        comptime Context: type,
-        comptime markMessageStartFn_: (fn (ctx: Context) void),
-        comptime peekFn_: (fn (ctx: Context) []const u8),
-        comptime skipFn_: (fn (ctx: Context, count: usize) void),
-        comptime ensureCapacityFn_: (fn (ctx: Context, count: usize) bool),
-        comptime readFunction_: (fn (ctx: Context, count: usize) anyerror!Data),
-        comptime readZ_: (fn (ctx: Context) anyerror!Data),
-    ) type {
-        return struct {
-            wrapped: Context,
-            const readFn = readFunction_;
-            const readZFn = readZ_;
-            const ensureCapacityFn = ensureCapacityFn_;
-            const skipFn = skipFn_;
-            const peekFn = peekFn_;
-            const markMessageStartFn = markMessageStartFn_;
-
-            pub const Ctx = Context;
-
-            pub inline fn markMessageStart(this: @This()) void {
-                markMessageStartFn(this.wrapped);
-            }
-
-            pub inline fn read(this: @This(), count: usize) anyerror!Data {
-                return try readFn(this.wrapped, count);
-            }
-
-            pub inline fn eatMessage(this: @This(), comptime msg_: anytype) anyerror!void {
-                const msg = msg_[1..];
-                try this.ensureCapacity(msg.len);
-
-                var input = try readFn(this.wrapped, msg.len);
-                defer input.deinit();
-                if (bun.strings.eqlComptime(input.slice(), msg)) return;
-                return error.InvalidMessage;
-            }
-
-            pub fn skip(this: @This(), count: usize) anyerror!void {
-                skipFn(this.wrapped, count);
-            }
-
-            pub fn peek(this: @This()) []const u8 {
-                return peekFn(this.wrapped);
-            }
-
-            pub inline fn readZ(this: @This()) anyerror!Data {
-                return try readZFn(this.wrapped);
-            }
-
-            pub inline fn ensureCapacity(this: @This(), count: usize) anyerror!void {
-                if (!ensureCapacityFn(this.wrapped, count)) {
-                    return error.ShortRead;
-                }
-            }
-
-            pub fn int(this: @This(), comptime Int: type) !Int {
-                var data = try this.read(@sizeOf((Int)));
-                defer data.deinit();
-                if (comptime Int == u8) {
-                    return @as(Int, data.slice()[0]);
-                }
-                return @byteSwap(@as(Int, @bitCast(data.slice()[0..@sizeOf(Int)].*)));
-            }
-
-            pub fn peekInt(this: @This(), comptime Int: type) ?Int {
-                const remain = this.peek();
-                if (remain.len < @sizeOf(Int)) {
-                    return null;
-                }
-                return @byteSwap(@as(Int, @bitCast(remain[0..@sizeOf(Int)].*)));
-            }
-
-            pub fn expectInt(this: @This(), comptime Int: type, comptime value: comptime_int) !bool {
-                const actual = try this.int(Int);
-                return actual == value;
-            }
-
-            pub fn int4(this: @This()) !PostgresInt32 {
-                return this.int(PostgresInt32);
-            }
-
-            pub fn short(this: @This()) !PostgresShort {
-                return this.int(PostgresShort);
-            }
-
-            pub fn length(this: @This()) !PostgresInt32 {
-                const expected = try this.int(PostgresInt32);
-                if (expected > -1) {
-                    try this.ensureCapacity(@intCast(expected -| 4));
-                }
-
-                return expected;
-            }
-
-            pub const bytes = read;
-
-            pub fn String(this: @This()) !bun.String {
-                var result = try this.readZ();
-                defer result.deinit();
-                return bun.String.fromUTF8(result.slice());
-            }
-        };
-    }
-
-    pub fn NewReader(comptime Context: type) type {
-        return NewReaderWrap(Context, Context.markMessageStart, Context.peek, Context.skip, Context.ensureLength, Context.read, Context.readZ);
-    }
-
-    pub fn NewWriter(comptime Context: type) type {
-        return NewWriterWrap(Context, Context.offset, Context.write, Context.pwrite);
-    }
-
-    fn decoderWrap(comptime Container: type, comptime decodeFn: anytype) type {
-        return struct {
-            pub fn decode(this: *Container, context: anytype) anyerror!void {
-                const Context = @TypeOf(context);
-                try decodeFn(this, Context, NewReader(Context){ .wrapped = context });
-            }
-        };
-    }
-
-    fn writeWrap(comptime Container: type, comptime writeFn: anytype) type {
-        return struct {
-            pub fn write(this: *Container, context: anytype) anyerror!void {
-                const Context = @TypeOf(context);
-                try writeFn(this, Context, NewWriter(Context){ .wrapped = context });
-            }
-        };
-    }
-
-    pub const Authentication = union(enum) {
-        Ok: void,
-        ClearTextPassword: struct {},
-        MD5Password: struct {
-            salt: [4]u8,
-        },
-        KerberosV5: struct {},
-        SCMCredential: struct {},
-        GSS: struct {},
-        GSSContinue: struct {
-            data: Data,
-        },
-        SSPI: struct {},
-        SASL: struct {},
-        SASLContinue: struct {
-            data: Data,
-            r: []const u8,
-            s: []const u8,
-            i: []const u8,
-
-            pub fn iterationCount(this: *const @This()) !u32 {
-                return try std.fmt.parseInt(u32, this.i, 0);
-            }
-        },
-        SASLFinal: struct {
-            data: Data,
-        },
-        Unknown: void,
-
-        pub fn deinit(this: *@This()) void {
-            switch (this.*) {
-                .MD5Password => {},
-                .SASL => {},
-                .SASLContinue => {
-                    this.SASLContinue.data.zdeinit();
-                },
-                .SASLFinal => {
-                    this.SASLFinal.data.zdeinit();
-                },
-                else => {},
-            }
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            const message_length = try reader.length();
-
-            switch (try reader.int4()) {
-                0 => {
-                    if (message_length != 8) return error.InvalidMessageLength;
-                    this.* = .{ .Ok = {} };
-                },
-                2 => {
-                    if (message_length != 8) return error.InvalidMessageLength;
-                    this.* = .{
-                        .KerberosV5 = .{},
-                    };
-                },
-                3 => {
-                    if (message_length != 8) return error.InvalidMessageLength;
-                    this.* = .{
-                        .ClearTextPassword = .{},
-                    };
-                },
-                5 => {
-                    if (message_length != 12) return error.InvalidMessageLength;
-                    if (!try reader.expectInt(u32, 5)) {
-                        return error.InvalidMessage;
-                    }
-                    var salt_data = try reader.bytes(4);
-                    defer salt_data.deinit();
-                    this.* = .{
-                        .MD5Password = .{
-                            .salt = salt_data.slice()[0..4].*,
-                        },
-                    };
-                },
-                7 => {
-                    if (message_length != 8) return error.InvalidMessageLength;
-                    this.* = .{
-                        .GSS = .{},
-                    };
-                },
-
-                8 => {
-                    if (message_length < 9) return error.InvalidMessageLength;
-                    const bytes = try reader.read(message_length - 8);
-                    this.* = .{
-                        .GSSContinue = .{
-                            .data = bytes,
-                        },
-                    };
-                },
-                9 => {
-                    if (message_length != 8) return error.InvalidMessageLength;
-                    this.* = .{
-                        .SSPI = .{},
-                    };
-                },
-
-                10 => {
-                    if (message_length < 9) return error.InvalidMessageLength;
-                    try reader.skip(message_length - 8);
-                    this.* = .{
-                        .SASL = .{},
-                    };
-                },
-
-                11 => {
-                    if (message_length < 9) return error.InvalidMessageLength;
-                    var bytes = try reader.bytes(message_length - 8);
-                    errdefer {
-                        bytes.deinit();
-                    }
-
-                    var iter = bun.strings.split(bytes.slice(), ",");
-                    var r: ?[]const u8 = null;
-                    var i: ?[]const u8 = null;
-                    var s: ?[]const u8 = null;
-
-                    while (iter.next()) |item| {
-                        if (item.len > 2) {
-                            const key = item[0];
-                            const after_equals = item[2..];
-                            if (key == 'r') {
-                                r = after_equals;
-                            } else if (key == 's') {
-                                s = after_equals;
-                            } else if (key == 'i') {
-                                i = after_equals;
-                            }
-                        }
-                    }
-
-                    if (r == null) {
-                        debug("Missing r", .{});
-                    }
-
-                    if (s == null) {
-                        debug("Missing s", .{});
-                    }
-
-                    if (i == null) {
-                        debug("Missing i", .{});
-                    }
-
-                    this.* = .{
-                        .SASLContinue = .{
-                            .data = bytes,
-                            .r = r orelse return error.InvalidMessage,
-                            .s = s orelse return error.InvalidMessage,
-                            .i = i orelse return error.InvalidMessage,
-                        },
-                    };
-                },
-
-                12 => {
-                    if (message_length < 9) return error.InvalidMessageLength;
-                    const remaining: usize = message_length - 8;
-
-                    const bytes = try reader.read(remaining);
-                    this.* = .{
-                        .SASLFinal = .{
-                            .data = bytes,
-                        },
-                    };
-                },
-
-                else => {
-                    this.* = .{ .Unknown = {} };
-                },
-            }
-        }
-
-        pub const decode = decoderWrap(Authentication, decodeInternal).decode;
-    };
-
-    pub const ParameterStatus = struct {
-        name: Data = .{ .empty = {} },
-        value: Data = .{ .empty = {} },
-
-        pub fn deinit(this: *@This()) void {
-            this.name.deinit();
-            this.value.deinit();
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            const length = try reader.length();
-            bun.assert(length >= 4);
-
-            this.* = .{
-                .name = try reader.readZ(),
-                .value = try reader.readZ(),
-            };
-        }
-
-        pub const decode = decoderWrap(ParameterStatus, decodeInternal).decode;
-    };
-
-    pub const BackendKeyData = struct {
-        process_id: u32 = 0,
-        secret_key: u32 = 0,
-        pub const decode = decoderWrap(BackendKeyData, decodeInternal).decode;
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            if (!try reader.expectInt(u32, 12)) {
-                return error.InvalidBackendKeyData;
-            }
-
-            this.* = .{
-                .process_id = @bitCast(try reader.int4()),
-                .secret_key = @bitCast(try reader.int4()),
-            };
-        }
-    };
-
-    pub const ErrorResponse = struct {
-        messages: std.ArrayListUnmanaged(FieldMessage) = .{},
-
-        pub fn format(formatter: ErrorResponse, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
-            for (formatter.messages.items) |message| {
-                try std.fmt.format(writer, "{}\n", .{message});
-            }
-        }
-
-        pub fn deinit(this: *ErrorResponse) void {
-            for (this.messages.items) |*message| {
-                message.deinit();
-            }
-            this.messages.deinit(bun.default_allocator);
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            var remaining_bytes = try reader.length();
-            if (remaining_bytes < 4) return error.InvalidMessageLength;
-            remaining_bytes -|= 4;
-
-            if (remaining_bytes > 0) {
-                this.* = .{
-                    .messages = try FieldMessage.decodeList(Container, reader),
-                };
-            }
-        }
-
-        pub const decode = decoderWrap(ErrorResponse, decodeInternal).decode;
-
-        pub fn toJS(this: ErrorResponse, globalObject: *JSC.JSGlobalObject) JSValue {
-            var b = bun.StringBuilder{};
-            defer b.deinit(bun.default_allocator);
-
-            for (this.messages.items) |msg| {
-                b.cap += switch (msg) {
-                    inline else => |m| m.utf8ByteLength(),
-                } + 1;
-            }
-            b.allocate(bun.default_allocator) catch {};
-
-            for (this.messages.items) |msg| {
-                var str = switch (msg) {
-                    inline else => |m| m.toUTF8(bun.default_allocator),
-                };
-                defer str.deinit();
-                _ = b.append(str.slice());
-                _ = b.append("\n");
-            }
-
-            return globalObject.createSyntaxErrorInstance("Postgres error occurred\n{s}", .{b.allocatedSlice()[0..b.len]});
-        }
-    };
-
-    pub const PortalOrPreparedStatement = union(enum) {
-        portal: []const u8,
-        prepared_statement: []const u8,
-
-        pub fn slice(this: @This()) []const u8 {
-            return switch (this) {
-                .portal => this.portal,
-                .prepared_statement => this.prepared_statement,
-            };
-        }
-
-        pub fn tag(this: @This()) u8 {
-            return switch (this) {
-                .portal => 'P',
-                .prepared_statement => 'S',
-            };
-        }
-    };
-
-    /// Close (F)
-    /// Byte1('C')
-    /// - Identifies the message as a Close command.
-    /// Int32
-    /// - Length of message contents in bytes, including self.
-    /// Byte1
-    /// - 'S' to close a prepared statement; or 'P' to close a portal.
-    /// String
-    /// - The name of the prepared statement or portal to close (an empty string selects the unnamed prepared statement or portal).
-    pub const Close = struct {
-        p: PortalOrPreparedStatement,
-
-        fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const p = this.p;
-            const count: u32 = @sizeOf((u32)) + 1 + p.slice().len + 1;
-            const header = [_]u8{
-                'C',
-            } ++ @byteSwap(count) ++ [_]u8{
-                p.tag(),
-            };
-            try writer.write(&header);
-            try writer.write(p.slice());
-            try writer.write(&[_]u8{0});
-        }
-
-        pub const write = writeWrap(@This(), writeInternal);
-    };
-
-    pub const CloseComplete = [_]u8{'3'} ++ toBytes(Int32(4));
-    pub const EmptyQueryResponse = [_]u8{'I'} ++ toBytes(Int32(4));
-    pub const Terminate = [_]u8{'X'} ++ toBytes(Int32(4));
-
-    fn Int32(value: anytype) [4]u8 {
-        return @bitCast(@byteSwap(@as(int4, @intCast(value))));
-    }
-
-    const toBytes = std.mem.toBytes;
-
-    pub const TransactionStatusIndicator = enum(u8) {
-        /// if idle (not in a transaction block)
-        I = 'I',
-
-        /// if in a transaction block
-        T = 'T',
-
-        /// if in a failed transaction block
-        E = 'E',
-
-        _,
-    };
-
-    pub const ReadyForQuery = struct {
-        status: TransactionStatusIndicator = .I,
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            const length = try reader.length();
-            bun.assert(length >= 4);
-
-            const status = try reader.int(u8);
-            this.* = .{
-                .status = @enumFromInt(status),
-            };
-        }
-
-        pub const decode = decoderWrap(ReadyForQuery, decodeInternal).decode;
-    };
-
-    pub const FormatCode = enum {
-        text,
-        binary,
-
-        pub fn from(value: short) !FormatCode {
-            return switch (value) {
-                0 => .text,
-                1 => .binary,
-                else => error.UnknownFormatCode,
-            };
-        }
-    };
-
-    pub const null_int4 = 4294967295;
-
-    pub const DataRow = struct {
-        pub fn decode(context: anytype, comptime ContextType: type, reader: NewReader(ContextType), comptime forEach: fn (@TypeOf(context), index: u32, bytes: ?*Data) anyerror!bool) anyerror!void {
-            var remaining_bytes = try reader.length();
-            remaining_bytes -|= 4;
-
-            const remaining_fields: usize = @intCast(@max(try reader.short(), 0));
-
-            for (0..remaining_fields) |index| {
-                const byte_length = try reader.int4();
-                switch (byte_length) {
-                    0 => break,
-                    null_int4 => {
-                        if (!try forEach(context, @intCast(index), null)) break;
-                    },
-                    else => {
-                        var bytes = try reader.bytes(@intCast(byte_length));
-                        if (!try forEach(context, @intCast(index), &bytes)) break;
-                    },
-                }
-            }
-        }
-    };
-
-    pub const BindComplete = [_]u8{'2'} ++ toBytes(Int32(4));
-
-    pub const FieldDescription = struct {
-        name: Data = .{ .empty = {} },
-        table_oid: int4 = 0,
-        column_index: short = 0,
-        type_oid: int4 = 0,
-
-        pub fn typeTag(this: @This()) types.Tag {
-            return @enumFromInt(@as(short, @truncate(this.type_oid)));
-        }
-
-        pub fn deinit(this: *@This()) void {
-            this.name.deinit();
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            var name = try reader.readZ();
-            errdefer {
-                name.deinit();
-            }
-            // If the field can be identified as a column of a specific table, the object ID of the table; otherwise zero.
-            // Int16
-            // If the field can be identified as a column of a specific table, the attribute number of the column; otherwise zero.
-            // Int32
-            // The object ID of the field's data type.
-            // Int16
-            // The data type size (see pg_type.typlen). Note that negative values denote variable-width types.
-            // Int32
-            // The type modifier (see pg_attribute.atttypmod). The meaning of the modifier is type-specific.
-            // Int16
-            // The format code being used for the field. Currently will be zero (text) or one (binary). In a RowDescription returned from the statement variant of Describe, the format code is not yet known and will always be zero.
-            this.* = .{
-                .table_oid = try reader.int4(),
-                .column_index = try reader.short(),
-                .type_oid = try reader.int4(),
-                .name = .{ .owned = try name.toOwned() },
-            };
-
-            try reader.skip(2 + 4 + 2);
-        }
-
-        pub const decode = decoderWrap(FieldDescription, decodeInternal).decode;
-    };
-
-    pub const RowDescription = struct {
-        fields: []const FieldDescription = &[_]FieldDescription{},
-        pub fn deinit(this: *@This()) void {
-            for (this.fields) |*field| {
-                @constCast(field).deinit();
-            }
-
-            bun.default_allocator.free(this.fields);
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            var remaining_bytes = try reader.length();
-            remaining_bytes -|= 4;
-
-            const field_count: usize = @intCast(@max(try reader.short(), 0));
-            var fields = try bun.default_allocator.alloc(
-                FieldDescription,
-                field_count,
-            );
-            var remaining = fields;
-            errdefer {
-                for (fields[0 .. field_count - remaining.len]) |*field| {
-                    field.deinit();
-                }
-
-                bun.default_allocator.free(fields);
-            }
-            while (remaining.len > 0) {
-                try remaining[0].decodeInternal(Container, reader);
-                remaining = remaining[1..];
-            }
-            this.* = .{
-                .fields = fields,
-            };
-        }
-
-        pub const decode = decoderWrap(RowDescription, decodeInternal).decode;
-    };
-
-    pub const ParameterDescription = struct {
-        parameters: []int4 = &[_]int4{},
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            var remaining_bytes = try reader.length();
-            remaining_bytes -|= 4;
-
-            const count = try reader.short();
-            const parameters = try bun.default_allocator.alloc(int4, @intCast(@max(count, 0)));
-
-            var data = try reader.read(@as(usize, @intCast(@max(count, 0))) * @sizeOf((int4)));
-            defer data.deinit();
-            const input_params: []align(1) const int4 = toInt32Slice(int4, data.slice());
-            for (input_params, parameters) |src, *dest| {
-                dest.* = @byteSwap(src);
-            }
-
-            this.* = .{
-                .parameters = parameters,
-            };
-        }
-
-        pub const decode = decoderWrap(ParameterDescription, decodeInternal).decode;
-    };
-
-    // workaround for zig compiler TODO
-    fn toInt32Slice(comptime Int: type, slice: []const u8) []align(1) const Int {
-        return @as([*]align(1) const Int, @ptrCast(slice.ptr))[0 .. slice.len / @sizeOf((Int))];
-    }
-
-    pub const NotificationResponse = struct {
-        pid: int4 = 0,
-        channel: bun.ByteList = .{},
-        payload: bun.ByteList = .{},
-
-        pub fn deinit(this: *@This()) void {
-            this.channel.deinitWithAllocator(bun.default_allocator);
-            this.payload.deinitWithAllocator(bun.default_allocator);
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            const length = try reader.length();
-            bun.assert(length >= 4);
-
-            this.* = .{
-                .pid = try reader.int4(),
-                .channel = (try reader.readZ()).toOwned(),
-                .payload = (try reader.readZ()).toOwned(),
-            };
-        }
-
-        pub const decode = decoderWrap(NotificationResponse, decodeInternal).decode;
-    };
-
-    pub const CommandComplete = struct {
-        command_tag: Data = .{ .empty = {} },
-
-        pub fn deinit(this: *@This()) void {
-            this.command_tag.deinit();
-        }
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            const length = try reader.length();
-            bun.assert(length >= 4);
-
-            const tag = try reader.readZ();
-            this.* = .{
-                .command_tag = tag,
-            };
-        }
-
-        pub const decode = decoderWrap(CommandComplete, decodeInternal).decode;
-    };
-
-    pub const Parse = struct {
-        name: []const u8 = "",
-        query: []const u8 = "",
-        params: []const int4 = &.{},
-
-        pub fn deinit(this: *Parse) void {
-            _ = this;
-        }
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const parameters = this.params;
-            const count: usize = @sizeOf((u32)) + @sizeOf(u16) + (parameters.len * @sizeOf(u32)) + @max(zCount(this.name), 1) + @max(zCount(this.query), 1);
-            const header = [_]u8{
-                'P',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.string(this.name);
-            try writer.string(this.query);
-            try writer.short(parameters.len);
-            for (parameters) |parameter| {
-                try writer.int4(parameter);
-            }
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const ParseComplete = [_]u8{'1'} ++ toBytes(Int32(4));
-
-    pub const PasswordMessage = struct {
-        password: Data = .{ .empty = {} },
-
-        pub fn deinit(this: *PasswordMessage) void {
-            this.password.deinit();
-        }
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const password = this.password.slice();
-            const count: usize = @sizeOf((u32)) + password.len + 1;
-            const header = [_]u8{
-                'p',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.string(password);
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const CopyData = struct {
-        data: Data = .{ .empty = {} },
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            const length = try reader.length();
-
-            const data = try reader.read(@intCast(length -| 5));
-            this.* = .{
-                .data = data,
-            };
-        }
-
-        pub const decode = decoderWrap(CopyData, decodeInternal).decode;
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const data = this.data.slice();
-            const count: u32 = @sizeOf((u32)) + data.len + 1;
-            const header = [_]u8{
-                'd',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.string(data);
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const CopyDone = [_]u8{'c'} ++ toBytes(Int32(4));
-    pub const Sync = [_]u8{'S'} ++ toBytes(Int32(4));
-    pub const Flush = [_]u8{'H'} ++ toBytes(Int32(4));
-    pub const SSLRequest = toBytes(Int32(8)) ++ toBytes(Int32(80877103));
-    pub const NoData = [_]u8{'n'} ++ toBytes(Int32(4));
-
-    pub const SASLInitialResponse = struct {
-        mechanism: Data = .{ .empty = {} },
-        data: Data = .{ .empty = {} },
-
-        pub fn deinit(this: *SASLInitialResponse) void {
-            this.mechanism.deinit();
-            this.data.deinit();
-        }
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const mechanism = this.mechanism.slice();
-            const data = this.data.slice();
-            const count: usize = @sizeOf(u32) + mechanism.len + 1 + data.len + @sizeOf(u32);
-            const header = [_]u8{
-                'p',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.string(mechanism);
-            try writer.int4(@truncate(data.len));
-            try writer.write(data);
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const SASLResponse = struct {
-        data: Data = .{ .empty = {} },
-
-        pub fn deinit(this: *SASLResponse) void {
-            this.data.deinit();
-        }
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const data = this.data.slice();
-            const count: usize = @sizeOf(u32) + data.len;
-            const header = [_]u8{
-                'p',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.write(data);
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const StartupMessage = struct {
-        user: Data,
-        database: Data,
-        options: Data = Data{ .empty = {} },
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const user = this.user.slice();
-            const database = this.database.slice();
-            const options = this.options.slice();
-
-            const count: usize = @sizeOf((int4)) + @sizeOf((int4)) + zFieldCount("user", user) + zFieldCount("database", database) + zFieldCount("client_encoding", "UTF8") + zFieldCount("", options) + 1;
-
-            const header = toBytes(Int32(@as(u32, @truncate(count))));
-            try writer.write(&header);
-            try writer.int4(196608);
-
-            try writer.string("user");
-            if (user.len > 0)
-                try writer.string(user);
-
-            try writer.string("database");
-
-            if (database.len == 0) {
-                // The database to connect to. Defaults to the user name.
-                try writer.string(user);
-            } else {
-                try writer.string(database);
-            }
-
-            try writer.string("client_encoding");
-            try writer.string("UTF8");
-
-            if (options.len > 0)
-                try writer.string(options);
-
-            try writer.write(&[_]u8{0});
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    fn zCount(slice: []const u8) usize {
-        return if (slice.len > 0) slice.len + 1 else 0;
-    }
-
-    fn zFieldCount(prefix: []const u8, slice: []const u8) usize {
-        if (slice.len > 0) {
-            return zCount(prefix) + zCount(slice);
-        }
-
-        return zCount(prefix);
-    }
-
-    pub const Execute = struct {
-        max_rows: int4 = 0,
-        p: PortalOrPreparedStatement,
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            try writer.write("E");
-            const length = try writer.length();
-            if (this.p == .portal)
-                try writer.string(this.p.portal)
-            else
-                try writer.write(&[_]u8{0});
-            try writer.int4(this.max_rows);
-            try length.write();
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const Describe = struct {
-        p: PortalOrPreparedStatement,
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const message = this.p.slice();
-            try writer.write(&[_]u8{
-                'D',
-            });
-            const length = try writer.length();
-            try writer.write(&[_]u8{
-                this.p.tag(),
-            });
-            try writer.string(message);
-            try length.write();
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const Query = struct {
-        message: Data = .{ .empty = {} },
-
-        pub fn deinit(this: *@This()) void {
-            this.message.deinit();
-        }
-
-        pub fn writeInternal(
-            this: *const @This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const message = this.message.slice();
-            const count: u32 = @sizeOf((u32)) + message.len + 1;
-            const header = [_]u8{
-                'Q',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.string(message);
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const NegotiateProtocolVersion = struct {
-        version: int4 = 0,
-        unrecognized_options: std.ArrayListUnmanaged(String) = .{},
-
-        pub fn decodeInternal(
-            this: *@This(),
-            comptime Container: type,
-            reader: NewReader(Container),
-        ) !void {
-            const length = try reader.length();
-            bun.assert(length >= 4);
-
-            const version = try reader.int4();
-            this.* = .{
-                .version = version,
-            };
-
-            const unrecognized_options_count: u32 = @intCast(@max(try reader.int4(), 0));
-            try this.unrecognized_options.ensureTotalCapacity(bun.default_allocator, unrecognized_options_count);
-            errdefer {
-                for (this.unrecognized_options.items) |*option| {
-                    option.deinit();
-                }
-                this.unrecognized_options.deinit(bun.default_allocator);
-            }
-            for (0..unrecognized_options_count) |_| {
-                var option = try reader.readZ();
-                if (option.slice().len == 0) break;
-                defer option.deinit();
-                this.unrecognized_options.appendAssumeCapacity(
-                    String.fromUTF8(option),
-                );
-            }
-        }
-    };
-
-    pub const NoticeResponse = struct {
-        messages: std.ArrayListUnmanaged(FieldMessage) = .{},
-        pub fn deinit(this: *NoticeResponse) void {
-            for (this.messages.items) |*message| {
-                message.deinit();
-            }
-            this.messages.deinit(bun.default_allocator);
-        }
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            var remaining_bytes = try reader.length();
-            remaining_bytes -|= 4;
-
-            if (remaining_bytes > 0) {
-                this.* = .{
-                    .messages = try FieldMessage.decodeList(Container, reader),
-                };
-            }
-        }
-        pub const decode = decoderWrap(NoticeResponse, decodeInternal).decode;
-    };
-
-    pub const CopyFail = struct {
-        message: Data = .{ .empty = {} },
-
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            _ = try reader.int4();
-
-            const message = try reader.readZ();
-            this.* = .{
-                .message = message,
-            };
-        }
-
-        pub const decode = decoderWrap(CopyFail, decodeInternal).decode;
-
-        pub fn writeInternal(
-            this: *@This(),
-            comptime Context: type,
-            writer: NewWriter(Context),
-        ) !void {
-            const message = this.message.slice();
-            const count: u32 = @sizeOf((u32)) + message.len + 1;
-            const header = [_]u8{
-                'f',
-            } ++ toBytes(Int32(count));
-            try writer.write(&header);
-            try writer.string(message);
-        }
-
-        pub const write = writeWrap(@This(), writeInternal).write;
-    };
-
-    pub const CopyInResponse = struct {
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            _ = reader;
-            _ = this;
-            TODO(@This());
-        }
-
-        pub const decode = decoderWrap(CopyInResponse, decodeInternal).decode;
-    };
-
-    pub const CopyOutResponse = struct {
-        pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
-            _ = reader;
-            _ = this;
-            TODO(@This());
-        }
-
-        pub const decode = decoderWrap(CopyInResponse, decodeInternal).decode;
-    };
-
-    fn TODO(comptime Type: type) !void {
-        std.debug.panic("TODO: not implemented {s}", .{bun.meta.typeBaseName(@typeName(Type))});
-    }
-};
-
-pub const types = struct {
-    //     select b.typname,  b.oid, b.typarray
-    //       from pg_catalog.pg_type a
-    //       left join pg_catalog.pg_type b on b.oid = a.typelem
-    //       where a.typcategory = 'A'
-    //       group by b.oid, b.typarray
-    //       order by b.oid
-    // ;
-    //                 typname                |  oid  | typarray
-    // ---------------------------------------+-------+----------
-    //  bool                                  |    16 |     1000
-    //  bytea                                 |    17 |     1001
-    //  char                                  |    18 |     1002
-    //  name                                  |    19 |     1003
-    //  int8                                  |    20 |     1016
-    //  int2                                  |    21 |     1005
-    //  int2vector                            |    22 |     1006
-    //  int4                                  |    23 |     1007
-    //  regproc                               |    24 |     1008
-    //  text                                  |    25 |     1009
-    //  oid                                   |    26 |     1028
-    //  tid                                   |    27 |     1010
-    //  xid                                   |    28 |     1011
-    //  cid                                   |    29 |     1012
-    //  oidvector                             |    30 |     1013
-    //  pg_type                               |    71 |      210
-    //  pg_attribute                          |    75 |      270
-    //  pg_proc                               |    81 |      272
-    //  pg_class                              |    83 |      273
-    //  json                                  |   114 |      199
-    //  xml                                   |   142 |      143
-    //  point                                 |   600 |     1017
-    //  lseg                                  |   601 |     1018
-    //  path                                  |   602 |     1019
-    //  box                                   |   603 |     1020
-    //  polygon                               |   604 |     1027
-    //  line                                  |   628 |      629
-    //  cidr                                  |   650 |      651
-    //  float4                                |   700 |     1021
-    //  float8                                |   701 |     1022
-    //  circle                                |   718 |      719
-    //  macaddr8                              |   774 |      775
-    //  money                                 |   790 |      791
-    //  macaddr                               |   829 |     1040
-    //  inet                                  |   869 |     1041
-    //  aclitem                               |  1033 |     1034
-    //  bpchar                                |  1042 |     1014
-    //  varchar                               |  1043 |     1015
-    //  date                                  |  1082 |     1182
-    //  time                                  |  1083 |     1183
-    //  timestamp                             |  1114 |     1115
-    //  timestamptz                           |  1184 |     1185
-    //  interval                              |  1186 |     1187
-    //  pg_database                           |  1248 |    12052
-    //  timetz                                |  1266 |     1270
-    //  bit                                   |  1560 |     1561
-    //  varbit                                |  1562 |     1563
-    //  numeric                               |  1700 |     1231
-    pub const Tag = enum(short) {
-        bool = 16,
-        bytea = 17,
-        char = 18,
-        name = 19,
-        int8 = 20,
-        int2 = 21,
-        int2vector = 22,
-        int4 = 23,
-        // regproc = 24,
-        text = 25,
-        // oid = 26,
-        // tid = 27,
-        // xid = 28,
-        // cid = 29,
-        // oidvector = 30,
-        // pg_type = 71,
-        // pg_attribute = 75,
-        // pg_proc = 81,
-        // pg_class = 83,
-        json = 114,
-        xml = 142,
-        point = 600,
-        lseg = 601,
-        path = 602,
-        box = 603,
-        polygon = 604,
-        line = 628,
-        cidr = 650,
-        float4 = 700,
-        float8 = 701,
-        circle = 718,
-        macaddr8 = 774,
-        money = 790,
-        macaddr = 829,
-        inet = 869,
-        aclitem = 1033,
-        bpchar = 1042,
-        varchar = 1043,
-        date = 1082,
-        time = 1083,
-        timestamp = 1114,
-        timestamptz = 1184,
-        interval = 1186,
-        pg_database = 1248,
-        timetz = 1266,
-        bit = 1560,
-        varbit = 1562,
-        numeric = 1700,
-        uuid = 2950,
-
-        bool_array = 1000,
-        bytea_array = 1001,
-        char_array = 1002,
-        name_array = 1003,
-        int8_array = 1016,
-        int2_array = 1005,
-        int2vector_array = 1006,
-        int4_array = 1007,
-        // regproc_array = 1008,
-        text_array = 1009,
-        oid_array = 1028,
-        tid_array = 1010,
-        xid_array = 1011,
-        cid_array = 1012,
-        // oidvector_array = 1013,
-        // pg_type_array = 210,
-        // pg_attribute_array = 270,
-        // pg_proc_array = 272,
-        // pg_class_array = 273,
-        json_array = 199,
-        xml_array = 143,
-        point_array = 1017,
-        lseg_array = 1018,
-        path_array = 1019,
-        box_array = 1020,
-        polygon_array = 1027,
-        line_array = 629,
-        cidr_array = 651,
-        float4_array = 1021,
-        float8_array = 1022,
-        circle_array = 719,
-        macaddr8_array = 775,
-        money_array = 791,
-        macaddr_array = 1040,
-        inet_array = 1041,
-        aclitem_array = 1034,
-        bpchar_array = 1014,
-        varchar_array = 1015,
-        date_array = 1182,
-        time_array = 1183,
-        timestamp_array = 1115,
-        timestamptz_array = 1185,
-        interval_array = 1187,
-        pg_database_array = 12052,
-        timetz_array = 1270,
-        bit_array = 1561,
-        varbit_array = 1563,
-        numeric_array = 1231,
-        _,
-
-        pub fn isBinaryFormatSupported(this: Tag) bool {
-            return switch (this) {
-                // TODO: .int2_array, .float8_array,
-                .int4_array, .float4_array, .int4, .float8, .float4, .bytea, .numeric => true,
-
-                else => false,
-            };
-        }
-
-        pub fn formatCode(this: Tag) short {
-            if (this.isBinaryFormatSupported()) {
-                return 1;
-            }
-
-            return 0;
-        }
-
-        fn PostgresBinarySingleDimensionArray(comptime T: type) type {
-            return extern struct {
-                // struct array_int4 {
-                //   int4_t ndim; /* Number of dimensions */
-                //   int4_t _ign; /* offset for data, removed by libpq */
-                //   Oid elemtype; /* type of element in the array */
-
-                //   /* First dimension */
-                //   int4_t size; /* Number of elements */
-                //   int4_t index; /* Index of first element */
-                //   int4_t first_value; /* Beginning of integer data */
-                // };
-
-                ndim: i32,
-                offset_for_data: i32,
-                element_type: i32,
-
-                len: i32,
-                index: i32,
-                first_value: T,
-
-                pub fn slice(this: *@This()) []T {
-                    if (this.len == 0) return &.{};
-
-                    var head = @as([*]T, @ptrCast(&this.first_value));
-                    var current = head;
-                    const len: usize = @intCast(this.len);
-                    for (0..len) |i| {
-                        // Skip every other value as it contains the size of the element
-                        current = current[1..];
-
-                        const val = current[0];
-                        const Int = std.meta.Int(.unsigned, @bitSizeOf(T));
-                        const swapped = @byteSwap(@as(Int, @bitCast(val)));
-
-                        head[i] = @bitCast(swapped);
-
-                        current = current[1..];
-                    }
-
-                    return head[0..len];
-                }
-
-                pub fn init(bytes: []const u8) *@This() {
-                    const this: *@This() = @alignCast(@ptrCast(@constCast(bytes.ptr)));
-                    this.ndim = @byteSwap(this.ndim);
-                    this.offset_for_data = @byteSwap(this.offset_for_data);
-                    this.element_type = @byteSwap(this.element_type);
-                    this.len = @byteSwap(this.len);
-                    this.index = @byteSwap(this.index);
-                    return this;
-                }
-            };
-        }
-
-        pub fn toJSTypedArrayType(comptime T: Tag) JSValue.JSType {
-            return comptime switch (T) {
-                .int4_array => .Int32Array,
-                // .int2_array => .Uint2Array,
-                .float4_array => .Float32Array,
-                // .float8_array => .Float64Array,
-                else => @compileError("TODO: not implemented"),
-            };
-        }
-
-        pub fn byteArrayType(comptime T: Tag) type {
-            return comptime switch (T) {
-                .int4_array => i32,
-                // .int2_array => i16,
-                .float4_array => f32,
-                // .float8_array => f64,
-                else => @compileError("TODO: not implemented"),
-            };
-        }
-
-        pub fn unsignedByteArrayType(comptime T: Tag) type {
-            return comptime switch (T) {
-                .int4_array => u32,
-                // .int2_array => u16,
-                .float4_array => f32,
-                // .float8_array => f64,
-                else => @compileError("TODO: not implemented"),
-            };
-        }
-
-        pub fn pgArrayType(comptime T: Tag) type {
-            return PostgresBinarySingleDimensionArray(byteArrayType(T));
-        }
-
-        fn toJSWithType(
-            tag: Tag,
-            globalObject: *JSC.JSGlobalObject,
-            comptime Type: type,
-            value: Type,
-        ) anyerror!JSValue {
-            switch (tag) {
-                .numeric => {
-                    return numeric.toJS(globalObject, value);
-                },
-
-                .float4, .float8 => {
-                    return numeric.toJS(globalObject, value);
-                },
-
-                .json => {
-                    return json.toJS(globalObject, value);
-                },
-
-                .bool => {
-                    return @"bool".toJS(globalObject, value);
-                },
-
-                .timestamp, .timestamptz => {
-                    return date.toJS(globalObject, value);
-                },
-
-                .bytea => {
-                    return bytea.toJS(globalObject, value);
-                },
-
-                .int8 => {
-                    return JSValue.fromInt64NoTruncate(globalObject, value);
-                },
-
-                .int4 => {
-                    return numeric.toJS(globalObject, value);
-                },
-
-                else => {
-                    return string.toJS(globalObject, value);
-                },
-            }
-        }
-
-        pub fn toJS(
-            tag: Tag,
-            globalObject: *JSC.JSGlobalObject,
-            value: anytype,
-        ) anyerror!JSValue {
-            return toJSWithType(tag, globalObject, @TypeOf(value), value);
-        }
-
-        pub fn fromJS(globalObject: *JSC.JSGlobalObject, value: JSValue) anyerror!Tag {
-            if (value.isEmptyOrUndefinedOrNull()) {
-                return Tag.numeric;
-            }
-
-            if (value.isCell()) {
-                const tag = value.jsType();
-                if (tag.isStringLike()) {
-                    return .text;
-                }
-
-                if (tag == .JSDate) {
-                    return .timestamp;
-                }
-
-                if (tag.isTypedArray()) {
-                    if (tag == .Int32Array)
-                        return .int4_array;
-
-                    return .bytea;
-                }
-
-                if (tag == .HeapBigInt) {
-                    return .int8;
-                }
-
-                if (tag.isArrayLike() and value.getLength(globalObject) > 0) {
-                    return Tag.fromJS(globalObject, value.getIndex(globalObject, 0));
-                }
-
-                // Ban these types:
-                if (tag == .NumberObject) {
-                    return error.JSError;
-                }
-
-                if (tag == .BooleanObject) {
-                    return error.JSError;
-                }
-
-                // It's something internal
-                if (!tag.isIndexable()) {
-                    return error.JSError;
-                }
-
-                // We will JSON.stringify anything else.
-                if (tag.isObject()) {
-                    return .json;
-                }
-            }
-
-            if (value.isInt32()) {
-                return .int4;
-            }
-
-            if (value.isNumber()) {
-                return .float8;
-            }
-
-            if (value.isBoolean()) {
-                return .bool;
-            }
-
-            return .numeric;
-        }
-    };
-
-    pub const string = struct {
-        pub const to = 25;
-        pub const from = [_]short{1002};
-
-        pub fn toJSWithType(
-            globalThis: *JSC.JSGlobalObject,
-            comptime Type: type,
-            value: Type,
-        ) anyerror!JSValue {
-            switch (comptime Type) {
-                [:0]u8, []u8, []const u8, [:0]const u8 => {
-                    var str = String.fromUTF8(value);
-                    defer str.deinit();
-                    return str.toJS(globalThis);
-                },
-
-                bun.String => {
-                    return value.toJS(globalThis);
-                },
-
-                *Data => {
-                    var str = String.fromUTF8(value.slice());
-                    defer str.deinit();
-                    defer value.deinit();
-                    return str.toJS(globalThis);
-                },
-
-                else => {
-                    @compileError("unsupported type " ++ @typeName(Type));
-                },
-            }
-        }
-
-        pub fn toJS(
-            globalThis: *JSC.JSGlobalObject,
-            value: anytype,
-        ) !JSValue {
-            var str = try toJSWithType(globalThis, @TypeOf(value), value);
-            defer str.deinit();
-            return str.toJS(globalThis);
-        }
-    };
-
-    pub const numeric = struct {
-        pub const to = 0;
-        pub const from = [_]short{ 21, 23, 26, 700, 701 };
+const Socket = uws.AnySocket;
+const PreparedStatementsMap = std.HashMapUnmanaged(u64, *PostgresSQLStatement, bun.IdentityContext(u64), 80);
 
-        pub fn toJS(
-            _: *JSC.JSGlobalObject,
-            value: anytype,
-        ) anyerror!JSValue {
-            return JSValue.jsNumber(value);
+const SocketMonitor = struct {
+    const DebugSocketMonitorWriter = struct {
+        var file: std.fs.File = undefined;
+        var enabled = false;
+        var check = std.once(load);
+        pub fn write(data: []const u8) void {
+            file.writeAll(data) catch {};
         }
-    };
-
-    pub const json = struct {
-        pub const to = 114;
-        pub const from = [_]short{ 114, 3802 };
 
-        pub fn toJS(
-            globalObject: *JSC.JSGlobalObject,
-            value: *Data,
-        ) anyerror!JSValue {
-            defer value.deinit();
-            var str = bun.String.fromUTF8(value.slice());
-            defer str.deref();
-            const parse_result = JSValue.parse(str.toJS(globalObject), globalObject);
-            if (parse_result.isAnyError()) {
-                globalObject.throwValue(parse_result);
-                return error.JSError;
+        fn load() void {
+            if (bun.getenvZAnyCase("BUN_POSTGRES_SOCKET_MONITOR")) |monitor| {
+                enabled = true;
+                file = std.fs.cwd().createFile(monitor, .{ .truncate = true }) catch {
+                    enabled = false;
+                    return;
+                };
+                debug("writing to {s}", .{monitor});
             }
-
-            return parse_result;
         }
     };
 
-    pub const @"bool" = struct {
-        pub const to = 16;
-        pub const from = [_]short{16};
+    const DebugSocketMonitorReader = struct {
+        var file: std.fs.File = undefined;
+        var enabled = false;
+        var check = std.once(load);
 
-        pub fn toJS(
-            _: *JSC.JSGlobalObject,
-            value: bool,
-        ) anyerror!JSValue {
-            return JSValue.jsBoolean(value);
+        fn load() void {
+            if (bun.getenvZAnyCase("BUN_POSTGRES_SOCKET_MONITOR_READER")) |monitor| {
+                enabled = true;
+                file = std.fs.cwd().createFile(monitor, .{ .truncate = true }) catch {
+                    enabled = false;
+                    return;
+                };
+                debug("duplicating reads to {s}", .{monitor});
+            }
         }
-    };
 
-    pub const date = struct {
-        pub const to = 1184;
-        pub const from = [_]short{ 1082, 1114, 1184 };
-
-        pub fn toJS(
-            globalObject: *JSC.JSGlobalObject,
-            value: *Data,
-        ) anyerror!JSValue {
-            defer value.deinit();
-            return JSValue.fromDateString(globalObject, value.sliceZ().ptr);
+        pub fn write(data: []const u8) void {
+            file.writeAll(data) catch {};
         }
     };
 
-    pub const bytea = struct {
-        pub const to = 17;
-        pub const from = [_]short{17};
-
-        pub fn toJS(
-            globalObject: *JSC.JSGlobalObject,
-            value: *Data,
-        ) anyerror!JSValue {
-            defer value.deinit();
+    pub fn write(data: []const u8) void {
+        if (comptime bun.Environment.isDebug) {
+            DebugSocketMonitorWriter.check.call();
+            if (DebugSocketMonitorWriter.enabled) {
+                DebugSocketMonitorWriter.write(data);
+            }
+        }
+    }
 
-            // var slice = value.slice()[@min(1, value.len)..];
-            // _ = slice;
-            return JSValue.createBuffer(globalObject, value.slice(), null);
+    pub fn read(data: []const u8) void {
+        if (comptime bun.Environment.isDebug) {
+            DebugSocketMonitorReader.check.call();
+            if (DebugSocketMonitorReader.enabled) {
+                DebugSocketMonitorReader.write(data);
+            }
         }
-    };
+    }
 };
 
-const Socket = uws.AnySocket;
-const PreparedStatementsMap = std.HashMapUnmanaged(u64, *PostgresSQLStatement, bun.IdentityContext(u64), 80);
-
 pub const PostgresSQLContext = struct {
     tcp: ?*uws.SocketContext = null,
 
     onQueryResolveFn: JSC.Strong = .{},
     onQueryRejectFn: JSC.Strong = .{},
 
-    pub fn init(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+    pub fn init(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         var ctx = &globalObject.bunVM().rareData().postgresql_context;
         ctx.onQueryResolveFn.set(globalObject, callframe.argument(0));
         ctx.onQueryRejectFn.set(globalObject, callframe.argument(1));
@@ -1988,9 +166,8 @@ pub const PostgresSQLContext = struct {
 
     comptime {
         if (!JSC.is_bindgen) {
-            @export(init, .{
-                .name = "PostgresSQLContext__init",
-            });
+            const js_init = JSC.toJSHostFunction(init);
+            @export(js_init, .{ .name = "PostgresSQLContext__init" });
         }
     }
 };
@@ -2236,10 +413,9 @@ pub const PostgresSQLQuery = struct {
         });
     }
 
-    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*PostgresSQLQuery {
+    pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*PostgresSQLQuery {
         _ = callframe;
-        globalThis.throw("PostgresSQLQuery cannot be constructed directly", .{});
-        return null;
+        return globalThis.throw2("PostgresSQLQuery cannot be constructed directly", .{});
     }
 
     pub fn estimatedSize(this: *PostgresSQLQuery) usize {
@@ -2247,10 +423,11 @@ pub const PostgresSQLQuery = struct {
         return @sizeOf(PostgresSQLQuery);
     }
 
-    pub fn call(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
-        const arguments = callframe.arguments(3).slice();
+    pub fn call(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
+        const arguments = callframe.arguments(4).slice();
         const query = arguments[0];
         const values = arguments[1];
+        const columns = arguments[3];
 
         if (!query.isString()) {
             globalThis.throw("query must be a string", .{});
@@ -2284,6 +461,9 @@ pub const PostgresSQLQuery = struct {
 
         PostgresSQLQuery.bindingSetCached(this_value, globalThis, values);
         PostgresSQLQuery.pendingValueSetCached(this_value, globalThis, pending_value);
+        if (columns != .undefined) {
+            PostgresSQLQuery.columnsSetCached(this_value, globalThis, columns);
+        }
         ptr.pending_value.set(globalThis, pending_value);
 
         return this_value;
@@ -2294,34 +474,36 @@ pub const PostgresSQLQuery = struct {
         pending_value.push(globalThis, value);
     }
 
-    pub fn doDone(this: *@This(), globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn doDone(this: *@This(), globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         _ = globalObject;
         this.is_done = true;
         return .undefined;
     }
 
-    pub fn doRun(this: *PostgresSQLQuery, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn doRun(this: *PostgresSQLQuery, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         var arguments_ = callframe.arguments(2);
         const arguments = arguments_.slice();
         var connection = arguments[0].as(PostgresSQLConnection) orelse {
             globalObject.throw("connection must be a PostgresSQLConnection", .{});
-            return .zero;
+            return error.JSError;
         };
         var query = arguments[1];
 
         if (!query.isObject()) {
             globalObject.throwInvalidArgumentType("run", "query", "Query");
-            return .zero;
+            return error.JSError;
         }
 
         this.target.set(globalObject, query);
         const binding_value = PostgresSQLQuery.bindingGetCached(callframe.this()) orelse .zero;
         var query_str = this.query.toUTF8(bun.default_allocator);
         defer query_str.deinit();
+        const columns_value = PostgresSQLQuery.columnsGetCached(callframe.this()) orelse .undefined;
 
-        var signature = Signature.generate(globalObject, query_str.slice(), binding_value) catch |err| {
-            globalObject.throwError(err, "failed to generate signature");
-            return .zero;
+        var signature = Signature.generate(globalObject, query_str.slice(), binding_value, columns_value) catch |err| {
+            if (!globalObject.hasException())
+                globalObject.throwError(err, "failed to generate signature");
+            return error.JSError;
         };
 
         var writer = connection.writer();
@@ -2329,7 +511,7 @@ pub const PostgresSQLQuery = struct {
         const entry = connection.statements.getOrPut(bun.default_allocator, bun.hash(signature.name)) catch |err| {
             globalObject.throwError(err, "failed to allocate statement");
             signature.deinit();
-            return .zero;
+            return error.JSError;
         };
 
         const has_params = signature.fields.len > 0;
@@ -2346,10 +528,11 @@ pub const PostgresSQLQuery = struct {
                 } else {
                     this.binary = this.statement.?.fields.len > 0;
 
-                    PostgresRequest.bindAndExecute(globalObject, this.statement.?, binding_value, PostgresSQLConnection.Writer, writer) catch |err| {
-                        globalObject.throwError(err, "failed to bind and execute query");
+                    PostgresRequest.bindAndExecute(globalObject, this.statement.?, binding_value, columns_value, PostgresSQLConnection.Writer, writer) catch |err| {
+                        if (!globalObject.hasException())
+                            globalObject.throwError(err, "failed to bind and execute query");
 
-                        return .zero;
+                        return error.JSError;
                     };
                     did_write = true;
                 }
@@ -2360,28 +543,31 @@ pub const PostgresSQLQuery = struct {
             // If it does not have params, we can write and execute immediately in one go
             if (!has_params) {
                 PostgresRequest.prepareAndQueryWithSignature(globalObject, query_str.slice(), binding_value, PostgresSQLConnection.Writer, writer, &signature) catch |err| {
-                    globalObject.throwError(err, "failed to prepare and query");
+                    if (!globalObject.hasException())
+                        globalObject.throwError(err, "failed to prepare and query");
                     signature.deinit();
-                    return .zero;
+                    return error.JSError;
                 };
                 did_write = true;
             } else {
                 PostgresRequest.writeQuery(query_str.slice(), signature.name, signature.fields, PostgresSQLConnection.Writer, writer) catch |err| {
-                    globalObject.throwError(err, "failed to write query");
+                    if (!globalObject.hasException())
+                        globalObject.throwError(err, "failed to write query");
                     signature.deinit();
-                    return .zero;
+                    return error.JSError;
                 };
                 writer.write(&protocol.Sync) catch |err| {
-                    globalObject.throwError(err, "failed to flush");
+                    if (!globalObject.hasException())
+                        globalObject.throwError(err, "failed to flush");
                     signature.deinit();
-                    return .zero;
+                    return error.JSError;
                 };
             }
 
             {
                 const stmt = bun.default_allocator.create(PostgresSQLStatement) catch |err| {
                     globalObject.throwError(err, "failed to allocate statement");
-                    return .zero;
+                    return error.JSError;
                 };
 
                 stmt.* = .{ .signature = signature, .ref_count = 2, .status = PostgresSQLStatement.Status.parsing };
@@ -2400,7 +586,7 @@ pub const PostgresSQLQuery = struct {
         return .undefined;
     }
 
-    pub fn doCancel(this: *PostgresSQLQuery, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn doCancel(this: *PostgresSQLQuery, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         _ = callframe;
         _ = globalObject;
         _ = this;
@@ -2410,7 +596,8 @@ pub const PostgresSQLQuery = struct {
 
     comptime {
         if (!JSC.is_bindgen) {
-            @export(call, .{ .name = "PostgresSQLQuery__createInstance" });
+            const jscall = JSC.toJSHostFunction(call);
+            @export(jscall, .{ .name = "PostgresSQLQuery__createInstance" });
         }
     }
 };
@@ -2421,6 +608,8 @@ pub const PostgresRequest = struct {
         cursor_name: bun.String,
         globalObject: *JSC.JSGlobalObject,
         values_array: JSValue,
+        columns_value: JSValue,
+        parameter_fields: []const int4,
         result_fields: []const protocol.FieldDescription,
         comptime Context: type,
         writer: protocol.NewWriter(Context),
@@ -2431,7 +620,7 @@ pub const PostgresRequest = struct {
         try writer.String(cursor_name);
         try writer.string(name);
 
-        var iter = JSC.JSArrayIterator.init(values_array, globalObject);
+        const len: u32 = @truncate(parameter_fields.len);
 
         // The number of parameter format codes that follow (denoted C
         // below). This can be zero to indicate that there are no
@@ -2439,10 +628,32 @@ pub const PostgresRequest = struct {
         // (text); or one, in which case the specified format code is
         // applied to all parameters; or it can equal the actual number
         // of parameters.
-        try writer.short(iter.len);
+        try writer.short(len);
 
-        while (iter.next()) |value| {
-            const tag = try types.Tag.fromJS(globalObject, value);
+        var iter = QueryBindingIterator.init(values_array, columns_value, globalObject);
+        for (0..len) |i| {
+            const tag: types.Tag = @enumFromInt(@as(short, @intCast(parameter_fields[i])));
+
+            const force_text = tag.isBinaryFormatSupported() and brk: {
+                iter.to(@truncate(i));
+                if (iter.next()) |value| {
+                    break :brk value.isString();
+                }
+                if (iter.anyFailed()) {
+                    return error.InvalidQueryBinding;
+                }
+                break :brk false;
+            };
+
+            if (force_text) {
+                // If they pass a value as a string, let's avoid attempting to
+                // convert it to the binary representation. This minimizes the room
+                // for mistakes on our end, such as stripping the timezone
+                // differently than what Postgres does when given a timestamp with
+                // timezone.
+                try writer.short(0);
+                continue;
+            }
 
             try writer.short(
                 tag.formatCode(),
@@ -2451,14 +662,14 @@ pub const PostgresRequest = struct {
 
         // The number of parameter values that follow (possibly zero). This
         // must match the number of parameters needed by the query.
-        try writer.short(iter.len);
-
-        iter = JSC.JSArrayIterator.init(values_array, globalObject);
+        try writer.short(len);
 
-        debug("Bind: {} ({d} args)", .{ bun.fmt.quote(name), iter.len });
-
-        while (iter.next()) |value| {
-            if (value.isUndefinedOrNull()) {
+        debug("Bind: {} ({d} args)", .{ bun.fmt.quote(name), len });
+        iter.to(0);
+        var i: usize = 0;
+        while (iter.next()) |value| : (i += 1) {
+            const tag: types.Tag = @enumFromInt(@as(short, @intCast(parameter_fields[i])));
+            if (value.isEmptyOrUndefinedOrNull()) {
                 debug("  -> NULL", .{});
                 //  As a special case, -1 indicates a
                 // NULL parameter value. No value bytes follow in the NULL case.
@@ -2466,10 +677,14 @@ pub const PostgresRequest = struct {
                 continue;
             }
 
-            const tag = try types.Tag.fromJS(globalObject, value);
-
             debug("  -> {s}", .{@tagName(tag)});
-            switch (tag) {
+            switch (
+            // If they pass a value as a string, let's avoid attempting to
+            // convert it to the binary representation. This minimizes the room
+            // for mistakes on our end, such as stripping the timezone
+            // differently than what Postgres does when given a timestamp with
+            // timezone.
+            if (tag.isBinaryFormatSupported() and value.isString()) .text else tag) {
                 .json => {
                     var str = bun.String.empty;
                     defer str.deref();
@@ -2482,14 +697,12 @@ pub const PostgresRequest = struct {
                 },
                 .bool => {
                     const l = try writer.length();
-                    try writer.bool(value.toBoolean());
+                    try writer.write(&[1]u8{@intFromBool(value.toBoolean())});
                     try l.writeExcludingSelf();
                 },
-                .time, .timestamp, .timestamptz => {
-                    var buf = std.mem.zeroes([28]u8);
-                    const str = value.toISOString(globalObject, &buf);
+                .timestamp, .timestamptz => {
                     const l = try writer.length();
-                    try writer.write(str);
+                    try writer.int8(types.date.fromJS(globalObject, value));
                     try l.writeExcludingSelf();
                 },
                 .bytea => {
@@ -2518,8 +731,9 @@ pub const PostgresRequest = struct {
                     try writer.f64(@bitCast(value.coerceToDouble(globalObject)));
                     try l.writeExcludingSelf();
                 },
+
                 else => {
-                    const str = String.fromJSRef(value, globalObject);
+                    const str = try String.fromJSRef(value, globalObject);
                     defer str.deref();
                     const slice = str.toUTF8WithoutRef(bun.default_allocator);
                     defer slice.deinit();
@@ -2589,7 +803,7 @@ pub const PostgresRequest = struct {
         signature: *Signature,
     ) !void {
         try writeQuery(query, signature.name, signature.fields, Context, writer);
-        try writeBind(signature.name, bun.String.empty, globalObject, array_value, &.{}, Context, writer);
+        try writeBind(signature.name, bun.String.empty, globalObject, array_value, .zero, &.{}, &.{}, Context, writer);
         var exec = protocol.Execute{
             .p = .{
                 .prepared_statement = signature.name,
@@ -2601,33 +815,15 @@ pub const PostgresRequest = struct {
         try writer.write(&protocol.Sync);
     }
 
-    pub fn prepareAndQuery(
-        globalObject: *JSC.JSGlobalObject,
-        query: bun.String,
-        array_value: JSValue,
-        comptime Context: type,
-        writer: protocol.NewWriter(Context),
-    ) !Signature {
-        var query_ = query.toUTF8(bun.default_allocator);
-        defer query_.deinit();
-        var signature = try Signature.generate(globalObject, query_.slice(), array_value);
-        errdefer {
-            signature.deinit();
-        }
-
-        try prepareAndQueryWithSignature(globalObject, query_.slice(), array_value, Context, writer, &signature);
-
-        return signature;
-    }
-
     pub fn bindAndExecute(
         globalObject: *JSC.JSGlobalObject,
         statement: *PostgresSQLStatement,
         array_value: JSValue,
+        columns_value: JSValue,
         comptime Context: type,
         writer: protocol.NewWriter(Context),
     ) !void {
-        try writeBind(statement.signature.name, bun.String.empty, globalObject, array_value, statement.fields, Context, writer);
+        try writeBind(statement.signature.name, bun.String.empty, globalObject, array_value, columns_value, statement.parameters, statement.fields, Context, writer);
         var exec = protocol.Execute{
             .p = .{
                 .prepared_statement = statement.signature.name,
@@ -2650,7 +846,16 @@ pub const PostgresRequest = struct {
             switch (try reader.int(u8)) {
                 'D' => try connection.on(.DataRow, Context, reader),
                 'd' => try connection.on(.CopyData, Context, reader),
-                'S' => try connection.on(.ParameterStatus, Context, reader),
+                'S' => {
+                    if (connection.tls_status == .message_sent) {
+                        bun.debugAssert(connection.tls_status.message_sent == 8);
+                        connection.tls_status = .ssl_ok;
+                        connection.setupTLS();
+                        return;
+                    }
+
+                    try connection.on(.ParameterStatus, Context, reader);
+                },
                 'Z' => try connection.on(.ReadyForQuery, Context, reader),
                 'C' => try connection.on(.CommandComplete, Context, reader),
                 '2' => try connection.on(.BindComplete, Context, reader),
@@ -2664,7 +869,19 @@ pub const PostgresRequest = struct {
                 's' => try connection.on(.PortalSuspended, Context, reader),
                 '3' => try connection.on(.CloseComplete, Context, reader),
                 'G' => try connection.on(.CopyInResponse, Context, reader),
-                'N' => try connection.on(.NoticeResponse, Context, reader),
+                'N' => {
+                    if (connection.tls_status == .message_sent) {
+                        connection.tls_status = .ssl_not_available;
+                        debug("Server does not support SSL", .{});
+                        if (connection.ssl_mode == .require) {
+                            connection.fail("Server does not support SSL", error.SSLNotAvailable);
+                            return;
+                        }
+                        continue;
+                    }
+
+                    try connection.on(.NoticeResponse, Context, reader);
+                },
                 'I' => try connection.on(.EmptyQueryResponse, Context, reader),
                 'H' => try connection.on(.CopyOutResponse, Context, reader),
                 'c' => try connection.on(.CopyDone, Context, reader),
@@ -2717,6 +934,23 @@ pub const PostgresSQLConnection = struct {
 
     authentication_state: AuthenticationState = .{ .pending = {} },
 
+    tls_ctx: ?*uws.SocketContext = null,
+    tls_config: JSC.API.ServerConfig.SSLConfig = .{},
+    tls_status: TLSStatus = .none,
+    ssl_mode: SSLMode = .disable,
+
+    pub const TLSStatus = union(enum) {
+        none,
+        pending,
+
+        /// Number of bytes sent of the 8-byte SSL request message.
+        /// Since we may send a partial message, we need to know how many bytes were sent.
+        message_sent: u8,
+
+        ssl_not_available,
+        ssl_ok,
+    };
+
     pub const AuthenticationState = union(enum) {
         pending: void,
         SASL: SASL,
@@ -2818,12 +1052,41 @@ pub const PostgresSQLConnection = struct {
     pub const Status = enum {
         disconnected,
         connecting,
+        // Prevent sending the startup message multiple times.
+        // Particularly relevant for TLS connections.
+        sent_startup_message,
         connected,
         failed,
     };
 
     pub usingnamespace JSC.Codegen.JSPostgresSQLConnection;
 
+    pub fn setupTLS(this: *PostgresSQLConnection) void {
+        debug("setupTLS", .{});
+        const new_socket = uws.us_socket_upgrade_to_tls(this.socket.SocketTCP.socket.connected, this.tls_ctx.?, this.tls_config.server_name) orelse {
+            this.fail("Failed to upgrade to TLS", error.TLSUpgradeFailed);
+            return;
+        };
+        this.socket = .{
+            .SocketTLS = .{
+                .socket = .{
+                    .connected = new_socket,
+                },
+            },
+        };
+
+        this.start();
+    }
+
+    fn start(this: *PostgresSQLConnection) void {
+        this.sendStartupMessage();
+
+        const event_loop = this.globalObject.bunVM().eventLoop();
+        event_loop.enter();
+        defer event_loop.exit();
+        this.flushData();
+    }
+
     pub fn hasPendingActivity(this: *PostgresSQLConnection) bool {
         @fence(.acquire);
         return this.pending_activity_count.load(.acquire) > 0;
@@ -2867,66 +1130,158 @@ pub const PostgresSQLConnection = struct {
         if (chunk.len == 0) return;
         const wrote = this.socket.write(chunk, false);
         if (wrote > 0) {
+            SocketMonitor.write(chunk[0..@intCast(wrote)]);
             this.write_buffer.consume(@intCast(wrote));
         }
     }
 
-    pub fn fail(this: *PostgresSQLConnection, message: []const u8, err: anyerror) void {
+    pub fn failWithJSValue(this: *PostgresSQLConnection, value: JSValue) void {
         defer this.updateHasPendingActivity();
         if (this.status == .failed) return;
-        debug("failed: {s}: {s}", .{ message, @errorName(err) });
 
         this.status = .failed;
         if (!this.socket.isClosed()) this.socket.close();
         const on_close = this.on_close.swap();
         if (on_close == .zero) return;
-        const instance = this.globalObject.createErrorInstance("{s}", .{message});
-        instance.put(this.globalObject, JSC.ZigString.static("code"), String.init(@errorName(err)).toJS(this.globalObject));
+
         _ = on_close.call(
             this.globalObject,
             this.js_value,
             &[_]JSValue{
-                instance,
+                value,
             },
         ) catch |e| this.globalObject.reportActiveExceptionAsUnhandled(e);
     }
 
+    pub fn fail(this: *PostgresSQLConnection, message: []const u8, err: anyerror) void {
+        debug("failed: {s}: {s}", .{ message, @errorName(err) });
+        const instance = this.globalObject.createErrorInstance("{s}", .{message});
+        instance.put(this.globalObject, JSC.ZigString.static("code"), String.init(@errorName(err)).toJS(this.globalObject));
+        this.failWithJSValue(instance);
+    }
+
     pub fn onClose(this: *PostgresSQLConnection) void {
         var vm = this.globalObject.bunVM();
         defer vm.drainMicrotasks();
         this.fail("Connection closed", error.ConnectionClosed);
     }
 
+    fn sendStartupMessage(this: *PostgresSQLConnection) void {
+        if (this.status != .connecting) return;
+        debug("sendStartupMessage", .{});
+        this.status = .sent_startup_message;
+        var msg = protocol.StartupMessage{
+            .user = Data{ .temporary = this.user },
+            .database = Data{ .temporary = this.database },
+            .options = Data{ .temporary = this.options },
+        };
+        msg.writeInternal(Writer, this.writer()) catch |err| {
+            this.socket.close();
+            this.fail("Failed to write startup message", err);
+        };
+    }
+
+    fn startTLS(this: *PostgresSQLConnection, socket: uws.AnySocket) void {
+        debug("startTLS", .{});
+        const offset = switch (this.tls_status) {
+            .message_sent => |count| count,
+            else => 0,
+        };
+        const ssl_request = [_]u8{
+            0x00, 0x00, 0x00, 0x08, // Length
+            0x04, 0xD2, 0x16, 0x2F, // SSL request code
+        };
+
+        const written = socket.write(ssl_request[offset..], false);
+        if (written > 0) {
+            this.tls_status = .{
+                .message_sent = offset + @as(u8, @intCast(written)),
+            };
+        } else {
+            this.tls_status = .{
+                .message_sent = offset,
+            };
+        }
+    }
+
     pub fn onOpen(this: *PostgresSQLConnection, socket: uws.AnySocket) void {
         this.socket = socket;
 
         this.poll_ref.ref(this.globalObject.bunVM());
         this.updateHasPendingActivity();
 
-        var msg = protocol.StartupMessage{ .user = Data{ .temporary = this.user }, .database = Data{ .temporary = this.database }, .options = Data{ .temporary = this.options } };
-        msg.writeInternal(Writer, this.writer()) catch |err| {
-            socket.close();
-            this.fail("Failed to write startup message", err);
-        };
+        if (this.tls_status == .message_sent or this.tls_status == .pending) {
+            this.startTLS(socket);
+            return;
+        }
 
-        this.flushData();
+        this.start();
+    }
+
+    pub fn onHandshake(this: *PostgresSQLConnection, success: i32, ssl_error: uws.us_bun_verify_error_t) void {
+        debug("onHandshake: {d} {d}", .{ success, ssl_error.error_no });
+
+        if (success != 1) {
+            this.failWithJSValue(ssl_error.toJS(this.globalObject));
+            return;
+        }
+
+        if (this.tls_config.reject_unauthorized == 1) {
+            if (ssl_error.error_no != 0) {
+                this.failWithJSValue(ssl_error.toJS(this.globalObject));
+                return;
+            }
+            const ssl_ptr = @as(*BoringSSL.SSL, @ptrCast(this.socket.getNativeHandle()));
+            if (BoringSSL.SSL_get_servername(ssl_ptr, 0)) |servername| {
+                const hostname = servername[0..bun.len(servername)];
+                if (!BoringSSL.checkServerIdentity(ssl_ptr, hostname)) {
+                    this.failWithJSValue(ssl_error.toJS(this.globalObject));
+                }
+            }
+        }
     }
 
     pub fn onTimeout(this: *PostgresSQLConnection) void {
-        var vm = this.globalObject.bunVM();
-        defer vm.drainMicrotasks();
+        _ = this; // autofix
         debug("onTimeout", .{});
     }
 
     pub fn onDrain(this: *PostgresSQLConnection) void {
-        var vm = this.globalObject.bunVM();
-        defer vm.drainMicrotasks();
+
+        // Don't send any other messages while we're waiting for TLS.
+        if (this.tls_status == .message_sent) {
+            if (this.tls_status.message_sent < 8) {
+                this.startTLS(this.socket);
+            }
+
+            return;
+        }
+
+        const event_loop = this.globalObject.bunVM().eventLoop();
+        event_loop.enter();
+        defer event_loop.exit();
         this.flushData();
     }
 
     pub fn onData(this: *PostgresSQLConnection, data: []const u8) void {
-        var vm = this.globalObject.bunVM();
-        defer vm.drainMicrotasks();
+        this.ref();
+        const vm = this.globalObject.bunVM();
+        defer {
+            if (this.status == .connected and this.requests.readableLength() == 0 and this.write_buffer.remaining().len == 0) {
+                // Don't keep the process alive when there's nothing to do.
+                this.poll_ref.unref(vm);
+            } else if (this.status == .connected) {
+                // Keep the process alive if there's something to do.
+                this.poll_ref.ref(vm);
+            }
+
+            this.deref();
+        }
+
+        const event_loop = vm.eventLoop();
+        event_loop.enter();
+        defer event_loop.exit();
+        SocketMonitor.read(data);
         if (this.read_buffer.remaining().len == 0) {
             var consumed: usize = 0;
             var offset: usize = 0;
@@ -3005,21 +1360,21 @@ pub const PostgresSQLConnection = struct {
         }
     }
 
-    pub fn constructor(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) ?*PostgresSQLConnection {
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!*PostgresSQLConnection {
         _ = callframe;
-        globalObject.throw("PostgresSQLConnection cannot be constructed directly", .{});
-        return null;
+        return globalObject.throw2("PostgresSQLConnection cannot be constructed directly", .{});
     }
 
     comptime {
         if (!JSC.is_bindgen) {
-            @export(call, .{ .name = "PostgresSQLConnection__createInstance" });
+            const jscall = JSC.toJSHostFunction(call);
+            @export(jscall, .{ .name = "PostgresSQLConnection__createInstance" });
         }
     }
 
-    pub fn call(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(JSC.conv) JSValue {
+    pub fn call(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         var vm = globalObject.bunVM();
-        const arguments = callframe.arguments(9).slice();
+        const arguments = callframe.arguments(10).slice();
         const hostname_str = arguments[0].toBunString(globalObject);
         defer hostname_str.deref();
         const port = arguments[1].coerce(i32, globalObject);
@@ -3030,13 +1385,67 @@ pub const PostgresSQLConnection = struct {
         defer password_str.deref();
         const database_str = arguments[4].toBunString(globalObject);
         defer database_str.deref();
-        const tls_object = arguments[5];
+        const ssl_mode: SSLMode = switch (arguments[5].toInt32()) {
+            0 => .disable,
+            1 => .prefer,
+            2 => .require,
+            3 => .verify_ca,
+            4 => .verify_full,
+            else => .disable,
+        };
+
+        const tls_object = arguments[6];
+
+        var tls_config: JSC.API.ServerConfig.SSLConfig = .{};
+        var tls_ctx: ?*uws.SocketContext = null;
+        if (ssl_mode != .disable) {
+            tls_config = if (tls_object.isBoolean() and tls_object.toBoolean())
+                .{}
+            else if (tls_object.isObject())
+                (JSC.API.ServerConfig.SSLConfig.fromJS(vm, globalObject, tls_object) catch return .zero) orelse .{}
+            else {
+                globalObject.throwInvalidArguments("tls must be a boolean or an object", .{});
+                return .zero;
+            };
+
+            if (globalObject.hasException()) {
+                tls_config.deinit();
+                return .zero;
+            }
+
+            if (tls_config.reject_unauthorized != 0)
+                tls_config.request_cert = 1;
+
+            // We create it right here so we can throw errors early.
+            const context_options = tls_config.asUSockets();
+            var err: uws.create_bun_socket_error_t = .none;
+            tls_ctx = uws.us_create_bun_socket_context(1, vm.uwsLoop(), @sizeOf(*PostgresSQLConnection), context_options, &err) orelse {
+                if (err != .none) {
+                    globalObject.throw("failed to create TLS context", .{});
+                } else {
+                    globalObject.throwValue(err.toJS(globalObject));
+                }
+                return .zero;
+            };
+
+            if (err != .none) {
+                tls_config.deinit();
+                globalObject.throwValue(err.toJS(globalObject));
+                if (tls_ctx) |ctx| {
+                    ctx.deinit(true);
+                }
+                return .zero;
+            }
+
+            uws.NewSocketHandler(true).configure(tls_ctx.?, true, *PostgresSQLConnection, SocketHandler(true));
+        }
+
         var username: []const u8 = "";
         var password: []const u8 = "";
         var database: []const u8 = "";
         var options: []const u8 = "";
 
-        const options_str = arguments[6].toBunString(globalObject);
+        const options_str = arguments[7].toBunString(globalObject);
         defer options_str.deref();
 
         const options_buf: []u8 = brk: {
@@ -3063,10 +1472,15 @@ pub const PostgresSQLConnection = struct {
             break :brk b.allocatedSlice();
         };
 
-        const on_connect = arguments[7];
-        const on_close = arguments[8];
+        const on_connect = arguments[8];
+        const on_close = arguments[9];
+
         var ptr = bun.default_allocator.create(PostgresSQLConnection) catch |err| {
             globalObject.throwError(err, "failed to allocate connection");
+            tls_config.deinit();
+            if (tls_ctx) |ctx| {
+                ctx.deinit(true);
+            }
             return .zero;
         };
 
@@ -3082,6 +1496,10 @@ pub const PostgresSQLConnection = struct {
             .socket = undefined,
             .requests = PostgresRequest.Queue.init(bun.default_allocator),
             .statements = PreparedStatementsMap{},
+            .tls_config = tls_config,
+            .tls_ctx = tls_ctx,
+            .ssl_mode = ssl_mode,
+            .tls_status = if (ssl_mode != .disable) .pending else .none,
         };
 
         ptr.updateHasPendingActivity();
@@ -3093,28 +1511,25 @@ pub const PostgresSQLConnection = struct {
         {
             const hostname = hostname_str.toUTF8(bun.default_allocator);
             defer hostname.deinit();
-            if (tls_object.isEmptyOrUndefinedOrNull()) {
-                const ctx = vm.rareData().postgresql_context.tcp orelse brk: {
-                    var err: uws.create_bun_socket_error_t = .none;
-                    const ctx_ = uws.us_create_bun_socket_context(0, vm.uwsLoop(), @sizeOf(*PostgresSQLConnection), uws.us_bun_socket_context_options_t{}, &err).?;
-                    uws.NewSocketHandler(false).configure(ctx_, true, *PostgresSQLConnection, SocketHandler(false));
-                    vm.rareData().postgresql_context.tcp = ctx_;
-                    break :brk ctx_;
-                };
-                ptr.socket = .{
-                    // TODO: investigate if allowHalfOpen: true is necessary here or if brings some advantage
-                    .SocketTCP = uws.SocketTCP.connectAnon(hostname.slice(), port, ctx, ptr, false) catch |err| {
-                        globalObject.throwError(err, "failed to connect to postgresql");
-                        ptr.deinit();
-                        return .zero;
-                    },
-                };
-            } else {
-                // TODO:
-                globalObject.throwTODO("TLS is not supported yet");
-                ptr.deinit();
-                return .zero;
-            }
+
+            const ctx = vm.rareData().postgresql_context.tcp orelse brk: {
+                var err: uws.create_bun_socket_error_t = .none;
+                const ctx_ = uws.us_create_bun_socket_context(0, vm.uwsLoop(), @sizeOf(*PostgresSQLConnection), uws.us_bun_socket_context_options_t{}, &err).?;
+                uws.NewSocketHandler(false).configure(ctx_, true, *PostgresSQLConnection, SocketHandler(false));
+                vm.rareData().postgresql_context.tcp = ctx_;
+                break :brk ctx_;
+            };
+            ptr.socket = .{
+                .SocketTCP = uws.SocketTCP.connectAnon(hostname.slice(), port, ctx, ptr, false) catch |err| {
+                    globalObject.throwError(err, "failed to connect to postgresql");
+                    tls_config.deinit();
+                    if (tls_ctx) |tls| {
+                        tls.deinit(true);
+                    }
+                    ptr.deinit();
+                    return .zero;
+                },
+            };
         }
 
         return js_value;
@@ -3134,6 +1549,12 @@ pub const PostgresSQLConnection = struct {
                 this.onOpen(_socket(socket));
             }
 
+            fn onHandshake_(this: *PostgresSQLConnection, _: anytype, success: i32, ssl_error: uws.us_bun_verify_error_t) void {
+                this.onHandshake(success, ssl_error);
+            }
+
+            pub const onHandshake = if (ssl) onHandshake_ else null;
+
             pub fn onClose(this: *PostgresSQLConnection, socket: SocketType, _: i32, _: ?*anyopaque) void {
                 _ = socket;
                 this.onClose();
@@ -3171,13 +1592,13 @@ pub const PostgresSQLConnection = struct {
         this.ref_count += 1;
     }
 
-    pub fn doRef(this: *@This(), _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn doRef(this: *@This(), _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.poll_ref.ref(this.globalObject.bunVM());
         this.updateHasPendingActivity();
         return .undefined;
     }
 
-    pub fn doUnref(this: *@This(), _: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn doUnref(this: *@This(), _: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         this.poll_ref.unref(this.globalObject.bunVM());
         this.updateHasPendingActivity();
         return .undefined;
@@ -3193,7 +1614,7 @@ pub const PostgresSQLConnection = struct {
         }
     }
 
-    pub fn doClose(this: *@This(), globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) JSValue {
+    pub fn doClose(this: *@This(), globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) bun.JSError!JSValue {
         _ = globalObject;
         this.disconnect();
         this.write_buffer.deinit(bun.default_allocator);
@@ -3214,6 +1635,7 @@ pub const PostgresSQLConnection = struct {
         this.on_connect.deinit();
         this.backend_parameters.deinit();
         bun.default_allocator.free(this.options_buf);
+        this.tls_config.deinit();
         bun.default_allocator.destroy(this);
     }
 
@@ -3321,10 +1743,11 @@ pub const PostgresSQLConnection = struct {
             int8 = 4,
             bool = 5,
             date = 6,
-            bytea = 7,
-            json = 8,
-            array = 9,
-            typed_array = 10,
+            date_with_time_zone = 7,
+            bytea = 8,
+            json = 9,
+            array = 10,
+            typed_array = 11,
         };
 
         pub const Value = extern union {
@@ -3335,6 +1758,7 @@ pub const PostgresSQLConnection = struct {
             int8: i64,
             bool: u8,
             date: f64,
+            date_with_time_zone: f64,
             bytea: [2]usize,
             json: bun.WTF.StringImpl,
             array: Array,
@@ -3478,12 +1902,24 @@ pub const PostgresSQLConnection = struct {
                     return DataCell{ .tag = .json, .value = .{ .json = String.createUTF8(bytes).value.WTFStringImpl }, .free_value = 1 };
                 },
                 .bool => {
-                    return DataCell{ .tag = .bool, .value = .{ .bool = @intFromBool(bytes.len > 0 and bytes[0] == 't') } };
+                    if (binary) {
+                        return DataCell{ .tag = .bool, .value = .{ .bool = @intFromBool(bytes.len > 0 and bytes[0] == 1) } };
+                    } else {
+                        return DataCell{ .tag = .bool, .value = .{ .bool = @intFromBool(bytes.len > 0 and bytes[0] == 't') } };
+                    }
                 },
-                .time, .timestamp, .timestamptz => {
-                    var str = bun.String.init(bytes);
-                    defer str.deref();
-                    return DataCell{ .tag = .date, .value = .{ .date = str.parseDate(globalObject) } };
+                .timestamp, .timestamptz => |tag| {
+                    if (binary and bytes.len == 8) {
+                        switch (tag) {
+                            .timestamptz => return DataCell{ .tag = .date_with_time_zone, .value = .{ .date_with_time_zone = types.date.fromBinary(bytes) } },
+                            .timestamp => return DataCell{ .tag = .date, .value = .{ .date = types.date.fromBinary(bytes) } },
+                            else => unreachable,
+                        }
+                    } else {
+                        var str = bun.String.init(bytes);
+                        defer str.deref();
+                        return DataCell{ .tag = .date, .value = .{ .date = str.parseDate(globalObject) } };
+                    }
                 },
                 .bytea => {
                     if (binary) {
@@ -3656,7 +2092,8 @@ pub const PostgresSQLConnection = struct {
                 .prepared => {
                     if (req.status == .pending and stmt.status == .prepared) {
                         const binding_value = PostgresSQLQuery.bindingGetCached(req.thisValue) orelse .zero;
-                        PostgresRequest.bindAndExecute(this.globalObject, stmt, binding_value, PostgresSQLConnection.Writer, this.writer()) catch |err| {
+                        const columns_value = PostgresSQLQuery.columnsGetCached(req.thisValue) orelse .zero;
+                        PostgresRequest.bindAndExecute(this.globalObject, stmt, binding_value, columns_value, PostgresSQLConnection.Writer, this.writer()) catch |err| {
                             req.onWriteFail(err, this.globalObject);
                             req.deref();
                             this.requests.discard(1);
@@ -3925,6 +2362,18 @@ pub const PostgresSQLConnection = struct {
                         this.fail("Unknown authentication method", error.UNKNOWN_AUTHENTICATION_METHOD);
                     },
 
+                    .ClearTextPassword => {
+                        debug("ClearTextPassword", .{});
+                        var response = protocol.PasswordMessage{
+                            .password = .{
+                                .temporary = this.password,
+                            },
+                        };
+
+                        try response.writeInternal(PostgresSQLConnection.Writer, this.writer());
+                        this.flushData();
+                    },
+
                     else => {
                         debug("TODO auth: {s}", .{@tagName(std.meta.activeTag(auth))});
                     },
@@ -4040,7 +2489,7 @@ pub const PostgresSQLConnection = struct {
         }
     }
 
-    pub fn doFlush(this: *PostgresSQLConnection, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn doFlush(this: *PostgresSQLConnection, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         _ = callframe;
         _ = globalObject;
         _ = this;
@@ -4048,7 +2497,7 @@ pub const PostgresSQLConnection = struct {
         return .undefined;
     }
 
-    pub fn createQuery(this: *PostgresSQLConnection, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) JSValue {
+    pub fn createQuery(this: *PostgresSQLConnection, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.JSError!JSValue {
         _ = callframe;
         _ = globalObject;
         _ = this;
@@ -4129,6 +2578,124 @@ pub const PostgresSQLStatement = struct {
     }
 };
 
+const QueryBindingIterator = union(enum) {
+    array: JSC.JSArrayIterator,
+    objects: ObjectIterator,
+
+    pub fn init(array: JSValue, columns: JSValue, globalObject: *JSC.JSGlobalObject) QueryBindingIterator {
+        if (columns.isEmptyOrUndefinedOrNull()) {
+            return .{ .array = JSC.JSArrayIterator.init(array, globalObject) };
+        }
+
+        return .{
+            .objects = .{
+                .array = array,
+                .columns = columns,
+                .globalObject = globalObject,
+                .columns_count = columns.getLength(globalObject),
+                .array_length = array.getLength(globalObject),
+            },
+        };
+    }
+
+    pub const ObjectIterator = struct {
+        array: JSValue,
+        columns: JSValue = .zero,
+        globalObject: *JSC.JSGlobalObject,
+        cell_i: usize = 0,
+        row_i: usize = 0,
+        current_row: JSC.JSValue = .zero,
+        columns_count: usize = 0,
+        array_length: usize = 0,
+        any_failed: bool = false,
+
+        pub fn next(this: *ObjectIterator) ?JSC.JSValue {
+            if (this.row_i >= this.array_length) {
+                return null;
+            }
+
+            const cell_i = this.cell_i;
+            this.cell_i += 1;
+            const row_i = this.row_i;
+
+            const globalObject = this.globalObject;
+
+            if (this.current_row == .zero) {
+                this.current_row = JSC.JSObject.getIndex(this.array, globalObject, @intCast(row_i));
+                if (this.current_row.isEmptyOrUndefinedOrNull()) {
+                    if (!globalObject.hasException())
+                        globalObject.throw("Expected a row to be returned at index {d}", .{row_i});
+                    this.any_failed = true;
+                    return null;
+                }
+            }
+
+            defer {
+                if (this.cell_i >= this.columns_count) {
+                    this.cell_i = 0;
+                    this.current_row = .zero;
+                    this.row_i += 1;
+                }
+            }
+
+            const property = JSC.JSObject.getIndex(this.columns, globalObject, @intCast(cell_i));
+            if (property == .zero or property == .undefined) {
+                if (!globalObject.hasException())
+                    globalObject.throw("Expected a column at index {d} in row {d}", .{ cell_i, row_i });
+                this.any_failed = true;
+                return null;
+            }
+
+            const value = this.current_row.getOwnByValue(globalObject, property);
+            if (value == .zero or value == .undefined) {
+                if (!globalObject.hasException())
+                    globalObject.throw("Expected a value at index {d} in row {d}", .{ cell_i, row_i });
+                this.any_failed = true;
+                return null;
+            }
+            return value;
+        }
+    };
+
+    pub fn next(this: *QueryBindingIterator) ?JSC.JSValue {
+        return switch (this.*) {
+            .array => |*iter| iter.next(),
+            .objects => |*iter| iter.next(),
+        };
+    }
+
+    pub fn anyFailed(this: *const QueryBindingIterator) bool {
+        return switch (this.*) {
+            .array => false,
+            .objects => |*iter| iter.any_failed,
+        };
+    }
+
+    pub fn to(this: *QueryBindingIterator, index: u32) void {
+        switch (this.*) {
+            .array => |*iter| iter.i = index,
+            .objects => |*iter| {
+                iter.cell_i = index % iter.columns_count;
+                iter.row_i = index / iter.columns_count;
+                iter.current_row = .zero;
+            },
+        }
+    }
+
+    pub fn reset(this: *QueryBindingIterator) void {
+        switch (this.*) {
+            .array => |*iter| {
+                iter.i = 0;
+            },
+            .objects => |*iter| {
+                iter.cell_i = 0;
+                iter.row_i = 0;
+                iter.current_row = .zero;
+            },
+        }
+    }
+};
+
 const Signature = struct {
     fields: []const int4,
     name: []const u8,
@@ -4147,7 +2714,7 @@ const Signature = struct {
         return hasher.final();
     }
 
-    pub fn generate(globalObject: *JSC.JSGlobalObject, query: []const u8, array_value: JSValue) !Signature {
+    pub fn generate(globalObject: *JSC.JSGlobalObject, query: []const u8, array_value: JSValue, columns: JSValue) !Signature {
         var fields = std.ArrayList(int4).init(bun.default_allocator);
         var name = try std.ArrayList(u8).initCapacity(bun.default_allocator, query.len);
 
@@ -4158,17 +2725,17 @@ const Signature = struct {
             name.deinit();
         }
 
-        var iter = JSC.JSArrayIterator.init(array_value, globalObject);
+        var iter = QueryBindingIterator.init(array_value, columns, globalObject);
 
         while (iter.next()) |value| {
-            if (value.isUndefinedOrNull()) {
+            if (value.isEmptyOrUndefinedOrNull()) {
+                // Allow postgres to decide the type
                 try fields.append(0);
                 try name.appendSlice(".null");
                 continue;
             }
 
             const tag = try types.Tag.fromJS(globalObject, value);
-            try fields.append(@intFromEnum(tag));
 
             switch (tag) {
                 .int8 => try name.appendSlice(".int8"),
@@ -4182,10 +2749,24 @@ const Signature = struct {
                 .bool => try name.appendSlice(".bool"),
                 .timestamp => try name.appendSlice(".timestamp"),
                 .timestamptz => try name.appendSlice(".timestamptz"),
-                .time => try name.appendSlice(".time"),
                 .bytea => try name.appendSlice(".bytea"),
                 else => try name.appendSlice(".string"),
             }
+
+            switch (tag) {
+                .bool, .int4, .int8, .float8, .int2, .numeric, .float4, .bytea => {
+                    // We decide the type
+                    try fields.append(@intFromEnum(tag));
+                },
+                else => {
+                    // Allow postgres to decide the type
+                    try fields.append(0);
+                },
+            }
+        }
+
+        if (iter.anyFailed()) {
+            return error.InvalidQueryBinding;
         }
 
         return Signature{
diff --git a/src/sql/postgres/postgres_protocol.zig b/src/sql/postgres/postgres_protocol.zig
new file mode 100644
index 00000000000000..4aee1791f90b38
--- /dev/null
+++ b/src/sql/postgres/postgres_protocol.zig
@@ -0,0 +1,1413 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const postgres = bun.JSC.Postgres;
+const Data = postgres.Data;
+const protocol = @This();
+const PostgresInt32 = postgres.PostgresInt32;
+const PostgresShort = postgres.PostgresShort;
+const String = bun.String;
+const debug = postgres.debug;
+const Crypto = JSC.API.Bun.Crypto;
+const JSValue = JSC.JSValue;
+const JSC = bun.JSC;
+const short = postgres.short;
+const int4 = postgres.int4;
+const int8 = postgres.int8;
+const PostgresInt64 = postgres.PostgresInt64;
+const types = postgres.types;
+
+pub const ArrayList = struct {
+    array: *std.ArrayList(u8),
+
+    pub fn offset(this: @This()) usize {
+        return this.array.items.len;
+    }
+
+    pub fn write(this: @This(), bytes: []const u8) anyerror!void {
+        try this.array.appendSlice(bytes);
+    }
+
+    pub fn pwrite(this: @This(), bytes: []const u8, i: usize) anyerror!void {
+        @memcpy(this.array.items[i..][0..bytes.len], bytes);
+    }
+
+    pub const Writer = NewWriter(@This());
+};
+
+pub const StackReader = struct {
+    buffer: []const u8 = "",
+    offset: *usize,
+    message_start: *usize,
+
+    pub fn markMessageStart(this: @This()) void {
+        this.message_start.* = this.offset.*;
+    }
+
+    pub fn ensureLength(this: @This(), length: usize) bool {
+        return this.buffer.len >= (this.offset.* + length);
+    }
+
+    pub fn init(buffer: []const u8, offset: *usize, message_start: *usize) protocol.NewReader(StackReader) {
+        return .{
+            .wrapped = .{
+                .buffer = buffer,
+                .offset = offset,
+                .message_start = message_start,
+            },
+        };
+    }
+
+    pub fn peek(this: StackReader) []const u8 {
+        return this.buffer[this.offset.*..];
+    }
+    pub fn skip(this: StackReader, count: usize) void {
+        if (this.offset.* + count > this.buffer.len) {
+            this.offset.* = this.buffer.len;
+            return;
+        }
+
+        this.offset.* += count;
+    }
+    pub fn ensureCapacity(this: StackReader, count: usize) bool {
+        return this.buffer.len >= (this.offset.* + count);
+    }
+    pub fn read(this: StackReader, count: usize) anyerror!Data {
+        const offset = this.offset.*;
+        if (!this.ensureCapacity(count)) {
+            return error.ShortRead;
+        }
+
+        this.skip(count);
+        return Data{
+            .temporary = this.buffer[offset..this.offset.*],
+        };
+    }
+    pub fn readZ(this: StackReader) anyerror!Data {
+        const remaining = this.peek();
+        if (bun.strings.indexOfChar(remaining, 0)) |zero| {
+            this.skip(zero + 1);
+            return Data{
+                .temporary = remaining[0..zero],
+            };
+        }
+
+        return error.ShortRead;
+    }
+};
+
+pub fn NewWriterWrap(
+    comptime Context: type,
+    comptime offsetFn_: (fn (ctx: Context) usize),
+    comptime writeFunction_: (fn (ctx: Context, bytes: []const u8) anyerror!void),
+    comptime pwriteFunction_: (fn (ctx: Context, bytes: []const u8, offset: usize) anyerror!void),
+) type {
+    return struct {
+        wrapped: Context,
+
+        const writeFn = writeFunction_;
+        const pwriteFn = pwriteFunction_;
+        const offsetFn = offsetFn_;
+        pub const Ctx = Context;
+
+        pub const WrappedWriter = @This();
+
+        pub inline fn write(this: @This(), data: []const u8) anyerror!void {
+            try writeFn(this.wrapped, data);
+        }
+
+        pub const LengthWriter = struct {
+            index: usize,
+            context: WrappedWriter,
+
+            pub fn write(this: LengthWriter) anyerror!void {
+                try this.context.pwrite(&Int32(this.context.offset() - this.index), this.index);
+            }
+
+            pub fn writeExcludingSelf(this: LengthWriter) anyerror!void {
+                try this.context.pwrite(&Int32(this.context.offset() -| (this.index + 4)), this.index);
+            }
+        };
+
+        pub inline fn length(this: @This()) anyerror!LengthWriter {
+            const i = this.offset();
+            try this.int4(0);
+            return LengthWriter{
+                .index = i,
+                .context = this,
+            };
+        }
+
+        pub inline fn offset(this: @This()) usize {
+            return offsetFn(this.wrapped);
+        }
+
+        pub inline fn pwrite(this: @This(), data: []const u8, i: usize) anyerror!void {
+            try pwriteFn(this.wrapped, data, i);
+        }
+
+        pub fn int4(this: @This(), value: PostgresInt32) !void {
+            try this.write(std.mem.asBytes(&@byteSwap(value)));
+        }
+
+        pub fn int8(this: @This(), value: PostgresInt64) !void {
+            try this.write(std.mem.asBytes(&@byteSwap(value)));
+        }
+
+        pub fn sint4(this: @This(), value: i32) !void {
+            try this.write(std.mem.asBytes(&@byteSwap(value)));
+        }
+
+        pub fn @"f64"(this: @This(), value: f64) !void {
+            try this.write(std.mem.asBytes(&@byteSwap(@as(u64, @bitCast(value)))));
+        }
+
+        pub fn @"f32"(this: @This(), value: f32) !void {
+            try this.write(std.mem.asBytes(&@byteSwap(@as(u32, @bitCast(value)))));
+        }
+
+        pub fn short(this: @This(), value: anytype) !void {
+            try this.write(std.mem.asBytes(&@byteSwap(@as(u16, @intCast(value)))));
+        }
+
+        pub fn string(this: @This(), value: []const u8) !void {
+            try this.write(value);
+            if (value.len == 0 or value[value.len - 1] != 0)
+                try this.write(&[_]u8{0});
+        }
+
+        pub fn bytes(this: @This(), value: []const u8) !void {
+            try this.write(value);
+            if (value.len == 0 or value[value.len - 1] != 0)
+                try this.write(&[_]u8{0});
+        }
+
+        pub fn @"bool"(this: @This(), value: bool) !void {
+            try this.write(if (value) "t" else "f");
+        }
+
+        pub fn @"null"(this: @This()) !void {
+            try this.int4(std.math.maxInt(PostgresInt32));
+        }
+
+        pub fn String(this: @This(), value: bun.String) !void {
+            if (value.isEmpty()) {
+                try this.write(&[_]u8{0});
+                return;
+            }
+
+            var sliced = value.toUTF8(bun.default_allocator);
+            defer sliced.deinit();
+            const slice = sliced.slice();
+
+            try this.write(slice);
+            if (slice.len == 0 or slice[slice.len - 1] != 0)
+                try this.write(&[_]u8{0});
+        }
+    };
+}
+
+pub const FieldType = enum(u8) {
+    /// Severity: the field contents are ERROR, FATAL, or PANIC (in an error message), or WARNING, NOTICE, DEBUG, INFO, or LOG (in a notice message), or a localized translation of one of these. Always present.
+    S = 'S',
+
+    /// Severity: the field contents are ERROR, FATAL, or PANIC (in an error message), or WARNING, NOTICE, DEBUG, INFO, or LOG (in a notice message). This is identical to the S field except that the contents are never localized. This is present only in messages generated by PostgreSQL versions 9.6 and later.
+    V = 'V',
+
+    /// Code: the SQLSTATE code for the error (see Appendix A). Not localizable. Always present.
+    C = 'C',
+
+    /// Message: the primary human-readable error message. This should be accurate but terse (typically one line). Always present.
+    M = 'M',
+
+    /// Detail: an optional secondary error message carrying more detail about the problem. Might run to multiple lines.
+    D = 'D',
+
+    /// Hint: an optional suggestion what to do about the problem. This is intended to differ from Detail in that it offers advice (potentially inappropriate) rather than hard facts. Might run to multiple lines.
+    H = 'H',
+
+    /// Position: the field value is a decimal ASCII integer, indicating an error cursor position as an index into the original query string. The first character has index 1, and positions are measured in characters not bytes.
+    P = 'P',
+
+    /// Internal position: this is defined the same as the P field, but it is used when the cursor position refers to an internally generated command rather than the one submitted by the client. The q field will always appear when this field appears.
+    p = 'p',
+
+    /// Internal query: the text of a failed internally-generated command. This could be, for example, an SQL query issued by a PL/pgSQL function.
+    q = 'q',
+
+    /// Where: an indication of the context in which the error occurred. Presently this includes a call stack traceback of active procedural language functions and internally-generated queries. The trace is one entry per line, most recent first.
+    W = 'W',
+
+    /// Schema name: if the error was associated with a specific database object, the name of the schema containing that object, if any.
+    s = 's',
+
+    /// Table name: if the error was associated with a specific table, the name of the table. (Refer to the schema name field for the name of the table's schema.)
+    t = 't',
+
+    /// Column name: if the error was associated with a specific table column, the name of the column. (Refer to the schema and table name fields to identify the table.)
+    c = 'c',
+
+    /// Data type name: if the error was associated with a specific data type, the name of the data type. (Refer to the schema name field for the name of the data type's schema.)
+    d = 'd',
+
+    /// Constraint name: if the error was associated with a specific constraint, the name of the constraint. Refer to fields listed above for the associated table or domain. (For this purpose, indexes are treated as constraints, even if they weren't created with constraint syntax.)
+    n = 'n',
+
+    /// File: the file name of the source-code location where the error was reported.
+    F = 'F',
+
+    /// Line: the line number of the source-code location where the error was reported.
+    L = 'L',
+
+    /// Routine: the name of the source-code routine reporting the error.
+    R = 'R',
+
+    _,
+};
+
+pub const FieldMessage = union(FieldType) {
+    S: String,
+    V: String,
+    C: String,
+    M: String,
+    D: String,
+    H: String,
+    P: String,
+    p: String,
+    q: String,
+    W: String,
+    s: String,
+    t: String,
+    c: String,
+    d: String,
+    n: String,
+    F: String,
+    L: String,
+    R: String,
+
+    pub fn format(this: FieldMessage, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        switch (this) {
+            inline else => |str| {
+                try std.fmt.format(writer, "{}", .{str});
+            },
+        }
+    }
+
+    pub fn deinit(this: *FieldMessage) void {
+        switch (this.*) {
+            inline else => |*message| {
+                message.deref();
+            },
+        }
+    }
+
+    pub fn decodeList(comptime Context: type, reader: NewReader(Context)) !std.ArrayListUnmanaged(FieldMessage) {
+        var messages = std.ArrayListUnmanaged(FieldMessage){};
+        while (true) {
+            const field_int = try reader.int(u8);
+            if (field_int == 0) break;
+            const field: FieldType = @enumFromInt(field_int);
+
+            var message = try reader.readZ();
+            defer message.deinit();
+            if (message.slice().len == 0) break;
+
+            try messages.append(bun.default_allocator, FieldMessage.init(field, message.slice()) catch continue);
+        }
+
+        return messages;
+    }
+
+    pub fn init(tag: FieldType, message: []const u8) !FieldMessage {
+        return switch (tag) {
+            .S => FieldMessage{ .S = String.createUTF8(message) },
+            .V => FieldMessage{ .V = String.createUTF8(message) },
+            .C => FieldMessage{ .C = String.createUTF8(message) },
+            .M => FieldMessage{ .M = String.createUTF8(message) },
+            .D => FieldMessage{ .D = String.createUTF8(message) },
+            .H => FieldMessage{ .H = String.createUTF8(message) },
+            .P => FieldMessage{ .P = String.createUTF8(message) },
+            .p => FieldMessage{ .p = String.createUTF8(message) },
+            .q => FieldMessage{ .q = String.createUTF8(message) },
+            .W => FieldMessage{ .W = String.createUTF8(message) },
+            .s => FieldMessage{ .s = String.createUTF8(message) },
+            .t => FieldMessage{ .t = String.createUTF8(message) },
+            .c => FieldMessage{ .c = String.createUTF8(message) },
+            .d => FieldMessage{ .d = String.createUTF8(message) },
+            .n => FieldMessage{ .n = String.createUTF8(message) },
+            .F => FieldMessage{ .F = String.createUTF8(message) },
+            .L => FieldMessage{ .L = String.createUTF8(message) },
+            .R => FieldMessage{ .R = String.createUTF8(message) },
+            else => error.UnknownFieldType,
+        };
+    }
+};
+
+pub fn NewReaderWrap(
+    comptime Context: type,
+    comptime markMessageStartFn_: (fn (ctx: Context) void),
+    comptime peekFn_: (fn (ctx: Context) []const u8),
+    comptime skipFn_: (fn (ctx: Context, count: usize) void),
+    comptime ensureCapacityFn_: (fn (ctx: Context, count: usize) bool),
+    comptime readFunction_: (fn (ctx: Context, count: usize) anyerror!Data),
+    comptime readZ_: (fn (ctx: Context) anyerror!Data),
+) type {
+    return struct {
+        wrapped: Context,
+        const readFn = readFunction_;
+        const readZFn = readZ_;
+        const ensureCapacityFn = ensureCapacityFn_;
+        const skipFn = skipFn_;
+        const peekFn = peekFn_;
+        const markMessageStartFn = markMessageStartFn_;
+
+        pub const Ctx = Context;
+
+        pub inline fn markMessageStart(this: @This()) void {
+            markMessageStartFn(this.wrapped);
+        }
+
+        pub inline fn read(this: @This(), count: usize) anyerror!Data {
+            return try readFn(this.wrapped, count);
+        }
+
+        pub inline fn eatMessage(this: @This(), comptime msg_: anytype) anyerror!void {
+            const msg = msg_[1..];
+            try this.ensureCapacity(msg.len);
+
+            var input = try readFn(this.wrapped, msg.len);
+            defer input.deinit();
+            if (bun.strings.eqlComptime(input.slice(), msg)) return;
+            return error.InvalidMessage;
+        }
+
+        pub fn skip(this: @This(), count: usize) anyerror!void {
+            skipFn(this.wrapped, count);
+        }
+
+        pub fn peek(this: @This()) []const u8 {
+            return peekFn(this.wrapped);
+        }
+
+        pub inline fn readZ(this: @This()) anyerror!Data {
+            return try readZFn(this.wrapped);
+        }
+
+        pub inline fn ensureCapacity(this: @This(), count: usize) anyerror!void {
+            if (!ensureCapacityFn(this.wrapped, count)) {
+                return error.ShortRead;
+            }
+        }
+
+        pub fn int(this: @This(), comptime Int: type) !Int {
+            var data = try this.read(@sizeOf((Int)));
+            defer data.deinit();
+            if (comptime Int == u8) {
+                return @as(Int, data.slice()[0]);
+            }
+            return @byteSwap(@as(Int, @bitCast(data.slice()[0..@sizeOf(Int)].*)));
+        }
+
+        pub fn peekInt(this: @This(), comptime Int: type) ?Int {
+            const remain = this.peek();
+            if (remain.len < @sizeOf(Int)) {
+                return null;
+            }
+            return @byteSwap(@as(Int, @bitCast(remain[0..@sizeOf(Int)].*)));
+        }
+
+        pub fn expectInt(this: @This(), comptime Int: type, comptime value: comptime_int) !bool {
+            const actual = try this.int(Int);
+            return actual == value;
+        }
+
+        pub fn int4(this: @This()) !PostgresInt32 {
+            return this.int(PostgresInt32);
+        }
+
+        pub fn short(this: @This()) !PostgresShort {
+            return this.int(PostgresShort);
+        }
+
+        pub fn length(this: @This()) !PostgresInt32 {
+            const expected = try this.int(PostgresInt32);
+            if (expected > -1) {
+                try this.ensureCapacity(@intCast(expected -| 4));
+            }
+
+            return expected;
+        }
+
+        pub const bytes = read;
+
+        pub fn String(this: @This()) !bun.String {
+            var result = try this.readZ();
+            defer result.deinit();
+            return bun.String.fromUTF8(result.slice());
+        }
+    };
+}
+
+pub fn NewReader(comptime Context: type) type {
+    return NewReaderWrap(Context, Context.markMessageStart, Context.peek, Context.skip, Context.ensureLength, Context.read, Context.readZ);
+}
+
+pub fn NewWriter(comptime Context: type) type {
+    return NewWriterWrap(Context, Context.offset, Context.write, Context.pwrite);
+}
+
+fn decoderWrap(comptime Container: type, comptime decodeFn: anytype) type {
+    return struct {
+        pub fn decode(this: *Container, context: anytype) anyerror!void {
+            const Context = @TypeOf(context);
+            try decodeFn(this, Context, NewReader(Context){ .wrapped = context });
+        }
+    };
+}
+
+fn writeWrap(comptime Container: type, comptime writeFn: anytype) type {
+    return struct {
+        pub fn write(this: *Container, context: anytype) anyerror!void {
+            const Context = @TypeOf(context);
+            try writeFn(this, Context, NewWriter(Context){ .wrapped = context });
+        }
+    };
+}
+
+pub const Authentication = union(enum) {
+    Ok: void,
+    ClearTextPassword: struct {},
+    MD5Password: struct {
+        salt: [4]u8,
+    },
+    KerberosV5: struct {},
+    SCMCredential: struct {},
+    GSS: struct {},
+    GSSContinue: struct {
+        data: Data,
+    },
+    SSPI: struct {},
+    SASL: struct {},
+    SASLContinue: struct {
+        data: Data,
+        r: []const u8,
+        s: []const u8,
+        i: []const u8,
+
+        pub fn iterationCount(this: *const @This()) !u32 {
+            return try std.fmt.parseInt(u32, this.i, 0);
+        }
+    },
+    SASLFinal: struct {
+        data: Data,
+    },
+    Unknown: void,
+
+    pub fn deinit(this: *@This()) void {
+        switch (this.*) {
+            .MD5Password => {},
+            .SASL => {},
+            .SASLContinue => {
+                this.SASLContinue.data.zdeinit();
+            },
+            .SASLFinal => {
+                this.SASLFinal.data.zdeinit();
+            },
+            else => {},
+        }
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        const message_length = try reader.length();
+
+        switch (try reader.int4()) {
+            0 => {
+                if (message_length != 8) return error.InvalidMessageLength;
+                this.* = .{ .Ok = {} };
+            },
+            2 => {
+                if (message_length != 8) return error.InvalidMessageLength;
+                this.* = .{
+                    .KerberosV5 = .{},
+                };
+            },
+            3 => {
+                if (message_length != 8) return error.InvalidMessageLength;
+                this.* = .{
+                    .ClearTextPassword = .{},
+                };
+            },
+            5 => {
+                if (message_length != 12) return error.InvalidMessageLength;
+                if (!try reader.expectInt(u32, 5)) {
+                    return error.InvalidMessage;
+                }
+                var salt_data = try reader.bytes(4);
+                defer salt_data.deinit();
+                this.* = .{
+                    .MD5Password = .{
+                        .salt = salt_data.slice()[0..4].*,
+                    },
+                };
+            },
+            7 => {
+                if (message_length != 8) return error.InvalidMessageLength;
+                this.* = .{
+                    .GSS = .{},
+                };
+            },
+
+            8 => {
+                if (message_length < 9) return error.InvalidMessageLength;
+                const bytes = try reader.read(message_length - 8);
+                this.* = .{
+                    .GSSContinue = .{
+                        .data = bytes,
+                    },
+                };
+            },
+            9 => {
+                if (message_length != 8) return error.InvalidMessageLength;
+                this.* = .{
+                    .SSPI = .{},
+                };
+            },
+
+            10 => {
+                if (message_length < 9) return error.InvalidMessageLength;
+                try reader.skip(message_length - 8);
+                this.* = .{
+                    .SASL = .{},
+                };
+            },
+
+            11 => {
+                if (message_length < 9) return error.InvalidMessageLength;
+                var bytes = try reader.bytes(message_length - 8);
+                errdefer {
+                    bytes.deinit();
+                }
+
+                var iter = bun.strings.split(bytes.slice(), ",");
+                var r: ?[]const u8 = null;
+                var i: ?[]const u8 = null;
+                var s: ?[]const u8 = null;
+
+                while (iter.next()) |item| {
+                    if (item.len > 2) {
+                        const key = item[0];
+                        const after_equals = item[2..];
+                        if (key == 'r') {
+                            r = after_equals;
+                        } else if (key == 's') {
+                            s = after_equals;
+                        } else if (key == 'i') {
+                            i = after_equals;
+                        }
+                    }
+                }
+
+                if (r == null) {
+                    debug("Missing r", .{});
+                }
+
+                if (s == null) {
+                    debug("Missing s", .{});
+                }
+
+                if (i == null) {
+                    debug("Missing i", .{});
+                }
+
+                this.* = .{
+                    .SASLContinue = .{
+                        .data = bytes,
+                        .r = r orelse return error.InvalidMessage,
+                        .s = s orelse return error.InvalidMessage,
+                        .i = i orelse return error.InvalidMessage,
+                    },
+                };
+            },
+
+            12 => {
+                if (message_length < 9) return error.InvalidMessageLength;
+                const remaining: usize = message_length - 8;
+
+                const bytes = try reader.read(remaining);
+                this.* = .{
+                    .SASLFinal = .{
+                        .data = bytes,
+                    },
+                };
+            },
+
+            else => {
+                this.* = .{ .Unknown = {} };
+            },
+        }
+    }
+
+    pub const decode = decoderWrap(Authentication, decodeInternal).decode;
+};
+
+pub const ParameterStatus = struct {
+    name: Data = .{ .empty = {} },
+    value: Data = .{ .empty = {} },
+
+    pub fn deinit(this: *@This()) void {
+        this.name.deinit();
+        this.value.deinit();
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        const length = try reader.length();
+        bun.assert(length >= 4);
+
+        this.* = .{
+            .name = try reader.readZ(),
+            .value = try reader.readZ(),
+        };
+    }
+
+    pub const decode = decoderWrap(ParameterStatus, decodeInternal).decode;
+};
+
+pub const BackendKeyData = struct {
+    process_id: u32 = 0,
+    secret_key: u32 = 0,
+    pub const decode = decoderWrap(BackendKeyData, decodeInternal).decode;
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        if (!try reader.expectInt(u32, 12)) {
+            return error.InvalidBackendKeyData;
+        }
+
+        this.* = .{
+            .process_id = @bitCast(try reader.int4()),
+            .secret_key = @bitCast(try reader.int4()),
+        };
+    }
+};
+
+pub const ErrorResponse = struct {
+    messages: std.ArrayListUnmanaged(FieldMessage) = .{},
+
+    pub fn format(formatter: ErrorResponse, comptime _: []const u8, _: std.fmt.FormatOptions, writer: anytype) !void {
+        for (formatter.messages.items) |message| {
+            try std.fmt.format(writer, "{}\n", .{message});
+        }
+    }
+
+    pub fn deinit(this: *ErrorResponse) void {
+        for (this.messages.items) |*message| {
+            message.deinit();
+        }
+        this.messages.deinit(bun.default_allocator);
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        var remaining_bytes = try reader.length();
+        if (remaining_bytes < 4) return error.InvalidMessageLength;
+        remaining_bytes -|= 4;
+
+        if (remaining_bytes > 0) {
+            this.* = .{
+                .messages = try FieldMessage.decodeList(Container, reader),
+            };
+        }
+    }
+
+    pub const decode = decoderWrap(ErrorResponse, decodeInternal).decode;
+
+    pub fn toJS(this: ErrorResponse, globalObject: *JSC.JSGlobalObject) JSValue {
+        var b = bun.StringBuilder{};
+        defer b.deinit(bun.default_allocator);
+
+        for (this.messages.items) |msg| {
+            b.cap += switch (msg) {
+                inline else => |m| m.utf8ByteLength(),
+            } + 1;
+        }
+        b.allocate(bun.default_allocator) catch {};
+
+        for (this.messages.items) |msg| {
+            var str = switch (msg) {
+                inline else => |m| m.toUTF8(bun.default_allocator),
+            };
+            defer str.deinit();
+            _ = b.append(str.slice());
+            _ = b.append("\n");
+        }
+
+        return globalObject.createSyntaxErrorInstance("Postgres error occurred\n{s}", .{b.allocatedSlice()[0..b.len]});
+    }
+};
+
+pub const PortalOrPreparedStatement = union(enum) {
+    portal: []const u8,
+    prepared_statement: []const u8,
+
+    pub fn slice(this: @This()) []const u8 {
+        return switch (this) {
+            .portal => this.portal,
+            .prepared_statement => this.prepared_statement,
+        };
+    }
+
+    pub fn tag(this: @This()) u8 {
+        return switch (this) {
+            .portal => 'P',
+            .prepared_statement => 'S',
+        };
+    }
+};
+
+/// Close (F)
+/// Byte1('C')
+/// - Identifies the message as a Close command.
+/// Int32
+/// - Length of message contents in bytes, including self.
+/// Byte1
+/// - 'S' to close a prepared statement; or 'P' to close a portal.
+/// String
+/// - The name of the prepared statement or portal to close (an empty string selects the unnamed prepared statement or portal).
+pub const Close = struct {
+    p: PortalOrPreparedStatement,
+
+    fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const p = this.p;
+        const count: u32 = @sizeOf((u32)) + 1 + p.slice().len + 1;
+        const header = [_]u8{
+            'C',
+        } ++ @byteSwap(count) ++ [_]u8{
+            p.tag(),
+        };
+        try writer.write(&header);
+        try writer.write(p.slice());
+        try writer.write(&[_]u8{0});
+    }
+
+    pub const write = writeWrap(@This(), writeInternal);
+};
+
+pub const CloseComplete = [_]u8{'3'} ++ toBytes(Int32(4));
+pub const EmptyQueryResponse = [_]u8{'I'} ++ toBytes(Int32(4));
+pub const Terminate = [_]u8{'X'} ++ toBytes(Int32(4));
+
+fn Int32(value: anytype) [4]u8 {
+    return @bitCast(@byteSwap(@as(int4, @intCast(value))));
+}
+
+const toBytes = std.mem.toBytes;
+
+pub const TransactionStatusIndicator = enum(u8) {
+    /// if idle (not in a transaction block)
+    I = 'I',
+
+    /// if in a transaction block
+    T = 'T',
+
+    /// if in a failed transaction block
+    E = 'E',
+
+    _,
+};
+
+pub const ReadyForQuery = struct {
+    status: TransactionStatusIndicator = .I,
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        const length = try reader.length();
+        bun.assert(length >= 4);
+
+        const status = try reader.int(u8);
+        this.* = .{
+            .status = @enumFromInt(status),
+        };
+    }
+
+    pub const decode = decoderWrap(ReadyForQuery, decodeInternal).decode;
+};
+
+pub const FormatCode = enum {
+    text,
+    binary,
+
+    pub fn from(value: short) !FormatCode {
+        return switch (value) {
+            0 => .text,
+            1 => .binary,
+            else => error.UnknownFormatCode,
+        };
+    }
+};
+
+pub const null_int4 = 4294967295;
+
+pub const DataRow = struct {
+    pub fn decode(context: anytype, comptime ContextType: type, reader: NewReader(ContextType), comptime forEach: fn (@TypeOf(context), index: u32, bytes: ?*Data) anyerror!bool) anyerror!void {
+        var remaining_bytes = try reader.length();
+        remaining_bytes -|= 4;
+
+        const remaining_fields: usize = @intCast(@max(try reader.short(), 0));
+
+        for (0..remaining_fields) |index| {
+            const byte_length = try reader.int4();
+            switch (byte_length) {
+                0 => break,
+                null_int4 => {
+                    if (!try forEach(context, @intCast(index), null)) break;
+                },
+                else => {
+                    var bytes = try reader.bytes(@intCast(byte_length));
+                    if (!try forEach(context, @intCast(index), &bytes)) break;
+                },
+            }
+        }
+    }
+};
+
+pub const BindComplete = [_]u8{'2'} ++ toBytes(Int32(4));
+
+pub const FieldDescription = struct {
+    name: Data = .{ .empty = {} },
+    table_oid: int4 = 0,
+    column_index: short = 0,
+    type_oid: int4 = 0,
+
+    pub fn typeTag(this: @This()) types.Tag {
+        return @enumFromInt(@as(short, @truncate(this.type_oid)));
+    }
+
+    pub fn deinit(this: *@This()) void {
+        this.name.deinit();
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        var name = try reader.readZ();
+        errdefer {
+            name.deinit();
+        }
+        // If the field can be identified as a column of a specific table, the object ID of the table; otherwise zero.
+        // Int16
+        // If the field can be identified as a column of a specific table, the attribute number of the column; otherwise zero.
+        // Int32
+        // The object ID of the field's data type.
+        // Int16
+        // The data type size (see pg_type.typlen). Note that negative values denote variable-width types.
+        // Int32
+        // The type modifier (see pg_attribute.atttypmod). The meaning of the modifier is type-specific.
+        // Int16
+        // The format code being used for the field. Currently will be zero (text) or one (binary). In a RowDescription returned from the statement variant of Describe, the format code is not yet known and will always be zero.
+        this.* = .{
+            .table_oid = try reader.int4(),
+            .column_index = try reader.short(),
+            .type_oid = try reader.int4(),
+            .name = .{ .owned = try name.toOwned() },
+        };
+
+        try reader.skip(2 + 4 + 2);
+    }
+
+    pub const decode = decoderWrap(FieldDescription, decodeInternal).decode;
+};
+
+pub const RowDescription = struct {
+    fields: []const FieldDescription = &[_]FieldDescription{},
+    pub fn deinit(this: *@This()) void {
+        for (this.fields) |*field| {
+            @constCast(field).deinit();
+        }
+
+        bun.default_allocator.free(this.fields);
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        var remaining_bytes = try reader.length();
+        remaining_bytes -|= 4;
+
+        const field_count: usize = @intCast(@max(try reader.short(), 0));
+        var fields = try bun.default_allocator.alloc(
+            FieldDescription,
+            field_count,
+        );
+        var remaining = fields;
+        errdefer {
+            for (fields[0 .. field_count - remaining.len]) |*field| {
+                field.deinit();
+            }
+
+            bun.default_allocator.free(fields);
+        }
+        while (remaining.len > 0) {
+            try remaining[0].decodeInternal(Container, reader);
+            remaining = remaining[1..];
+        }
+        this.* = .{
+            .fields = fields,
+        };
+    }
+
+    pub const decode = decoderWrap(RowDescription, decodeInternal).decode;
+};
+
+pub const ParameterDescription = struct {
+    parameters: []int4 = &[_]int4{},
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        var remaining_bytes = try reader.length();
+        remaining_bytes -|= 4;
+
+        const count = try reader.short();
+        const parameters = try bun.default_allocator.alloc(int4, @intCast(@max(count, 0)));
+
+        var data = try reader.read(@as(usize, @intCast(@max(count, 0))) * @sizeOf((int4)));
+        defer data.deinit();
+        const input_params: []align(1) const int4 = toInt32Slice(int4, data.slice());
+        for (input_params, parameters) |src, *dest| {
+            dest.* = @byteSwap(src);
+        }
+
+        this.* = .{
+            .parameters = parameters,
+        };
+    }
+
+    pub const decode = decoderWrap(ParameterDescription, decodeInternal).decode;
+};
+
+// workaround for zig compiler TODO
+fn toInt32Slice(comptime Int: type, slice: []const u8) []align(1) const Int {
+    return @as([*]align(1) const Int, @ptrCast(slice.ptr))[0 .. slice.len / @sizeOf((Int))];
+}
+
+pub const NotificationResponse = struct {
+    pid: int4 = 0,
+    channel: bun.ByteList = .{},
+    payload: bun.ByteList = .{},
+
+    pub fn deinit(this: *@This()) void {
+        this.channel.deinitWithAllocator(bun.default_allocator);
+        this.payload.deinitWithAllocator(bun.default_allocator);
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        const length = try reader.length();
+        bun.assert(length >= 4);
+
+        this.* = .{
+            .pid = try reader.int4(),
+            .channel = (try reader.readZ()).toOwned(),
+            .payload = (try reader.readZ()).toOwned(),
+        };
+    }
+
+    pub const decode = decoderWrap(NotificationResponse, decodeInternal).decode;
+};
+
+pub const CommandComplete = struct {
+    command_tag: Data = .{ .empty = {} },
+
+    pub fn deinit(this: *@This()) void {
+        this.command_tag.deinit();
+    }
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        const length = try reader.length();
+        bun.assert(length >= 4);
+
+        const tag = try reader.readZ();
+        this.* = .{
+            .command_tag = tag,
+        };
+    }
+
+    pub const decode = decoderWrap(CommandComplete, decodeInternal).decode;
+};
+
+pub const Parse = struct {
+    name: []const u8 = "",
+    query: []const u8 = "",
+    params: []const int4 = &.{},
+
+    pub fn deinit(this: *Parse) void {
+        _ = this;
+    }
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const parameters = this.params;
+        const count: usize = @sizeOf((u32)) + @sizeOf(u16) + (parameters.len * @sizeOf(u32)) + @max(zCount(this.name), 1) + @max(zCount(this.query), 1);
+        const header = [_]u8{
+            'P',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.string(this.name);
+        try writer.string(this.query);
+        try writer.short(parameters.len);
+        for (parameters) |parameter| {
+            try writer.int4(parameter);
+        }
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const ParseComplete = [_]u8{'1'} ++ toBytes(Int32(4));
+
+pub const PasswordMessage = struct {
+    password: Data = .{ .empty = {} },
+
+    pub fn deinit(this: *PasswordMessage) void {
+        this.password.deinit();
+    }
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const password = this.password.slice();
+        const count: usize = @sizeOf((u32)) + password.len + 1;
+        const header = [_]u8{
+            'p',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.string(password);
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const CopyData = struct {
+    data: Data = .{ .empty = {} },
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        const length = try reader.length();
+
+        const data = try reader.read(@intCast(length -| 5));
+        this.* = .{
+            .data = data,
+        };
+    }
+
+    pub const decode = decoderWrap(CopyData, decodeInternal).decode;
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const data = this.data.slice();
+        const count: u32 = @sizeOf((u32)) + data.len + 1;
+        const header = [_]u8{
+            'd',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.string(data);
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const CopyDone = [_]u8{'c'} ++ toBytes(Int32(4));
+pub const Sync = [_]u8{'S'} ++ toBytes(Int32(4));
+pub const Flush = [_]u8{'H'} ++ toBytes(Int32(4));
+pub const SSLRequest = toBytes(Int32(8)) ++ toBytes(Int32(80877103));
+pub const NoData = [_]u8{'n'} ++ toBytes(Int32(4));
+
+pub const SASLInitialResponse = struct {
+    mechanism: Data = .{ .empty = {} },
+    data: Data = .{ .empty = {} },
+
+    pub fn deinit(this: *SASLInitialResponse) void {
+        this.mechanism.deinit();
+        this.data.deinit();
+    }
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const mechanism = this.mechanism.slice();
+        const data = this.data.slice();
+        const count: usize = @sizeOf(u32) + mechanism.len + 1 + data.len + @sizeOf(u32);
+        const header = [_]u8{
+            'p',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.string(mechanism);
+        try writer.int4(@truncate(data.len));
+        try writer.write(data);
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const SASLResponse = struct {
+    data: Data = .{ .empty = {} },
+
+    pub fn deinit(this: *SASLResponse) void {
+        this.data.deinit();
+    }
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const data = this.data.slice();
+        const count: usize = @sizeOf(u32) + data.len;
+        const header = [_]u8{
+            'p',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.write(data);
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const StartupMessage = struct {
+    user: Data,
+    database: Data,
+    options: Data = Data{ .empty = {} },
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const user = this.user.slice();
+        const database = this.database.slice();
+        const options = this.options.slice();
+
+        const count: usize = @sizeOf((int4)) + @sizeOf((int4)) + zFieldCount("user", user) + zFieldCount("database", database) + zFieldCount("client_encoding", "UTF8") + zFieldCount("", options) + 1;
+
+        const header = toBytes(Int32(@as(u32, @truncate(count))));
+        try writer.write(&header);
+        try writer.int4(196608);
+
+        try writer.string("user");
+        if (user.len > 0)
+            try writer.string(user);
+
+        try writer.string("database");
+
+        if (database.len == 0) {
+            // The database to connect to. Defaults to the user name.
+            try writer.string(user);
+        } else {
+            try writer.string(database);
+        }
+
+        try writer.string("client_encoding");
+        try writer.string("UTF8");
+
+        if (options.len > 0)
+            try writer.string(options);
+
+        try writer.write(&[_]u8{0});
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+fn zCount(slice: []const u8) usize {
+    return if (slice.len > 0) slice.len + 1 else 0;
+}
+
+fn zFieldCount(prefix: []const u8, slice: []const u8) usize {
+    if (slice.len > 0) {
+        return zCount(prefix) + zCount(slice);
+    }
+
+    return zCount(prefix);
+}
+
+pub const Execute = struct {
+    max_rows: int4 = 0,
+    p: PortalOrPreparedStatement,
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        try writer.write("E");
+        const length = try writer.length();
+        if (this.p == .portal)
+            try writer.string(this.p.portal)
+        else
+            try writer.write(&[_]u8{0});
+        try writer.int4(this.max_rows);
+        try length.write();
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const Describe = struct {
+    p: PortalOrPreparedStatement,
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const message = this.p.slice();
+        try writer.write(&[_]u8{
+            'D',
+        });
+        const length = try writer.length();
+        try writer.write(&[_]u8{
+            this.p.tag(),
+        });
+        try writer.string(message);
+        try length.write();
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const Query = struct {
+    message: Data = .{ .empty = {} },
+
+    pub fn deinit(this: *@This()) void {
+        this.message.deinit();
+    }
+
+    pub fn writeInternal(
+        this: *const @This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const message = this.message.slice();
+        const count: u32 = @sizeOf((u32)) + message.len + 1;
+        const header = [_]u8{
+            'Q',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.string(message);
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const NegotiateProtocolVersion = struct {
+    version: int4 = 0,
+    unrecognized_options: std.ArrayListUnmanaged(String) = .{},
+
+    pub fn decodeInternal(
+        this: *@This(),
+        comptime Container: type,
+        reader: NewReader(Container),
+    ) !void {
+        const length = try reader.length();
+        bun.assert(length >= 4);
+
+        const version = try reader.int4();
+        this.* = .{
+            .version = version,
+        };
+
+        const unrecognized_options_count: u32 = @intCast(@max(try reader.int4(), 0));
+        try this.unrecognized_options.ensureTotalCapacity(bun.default_allocator, unrecognized_options_count);
+        errdefer {
+            for (this.unrecognized_options.items) |*option| {
+                option.deinit();
+            }
+            this.unrecognized_options.deinit(bun.default_allocator);
+        }
+        for (0..unrecognized_options_count) |_| {
+            var option = try reader.readZ();
+            if (option.slice().len == 0) break;
+            defer option.deinit();
+            this.unrecognized_options.appendAssumeCapacity(
+                String.fromUTF8(option),
+            );
+        }
+    }
+};
+
+pub const NoticeResponse = struct {
+    messages: std.ArrayListUnmanaged(FieldMessage) = .{},
+    pub fn deinit(this: *NoticeResponse) void {
+        for (this.messages.items) |*message| {
+            message.deinit();
+        }
+        this.messages.deinit(bun.default_allocator);
+    }
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        var remaining_bytes = try reader.length();
+        remaining_bytes -|= 4;
+
+        if (remaining_bytes > 0) {
+            this.* = .{
+                .messages = try FieldMessage.decodeList(Container, reader),
+            };
+        }
+    }
+    pub const decode = decoderWrap(NoticeResponse, decodeInternal).decode;
+};
+
+pub const CopyFail = struct {
+    message: Data = .{ .empty = {} },
+
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        _ = try reader.int4();
+
+        const message = try reader.readZ();
+        this.* = .{
+            .message = message,
+        };
+    }
+
+    pub const decode = decoderWrap(CopyFail, decodeInternal).decode;
+
+    pub fn writeInternal(
+        this: *@This(),
+        comptime Context: type,
+        writer: NewWriter(Context),
+    ) !void {
+        const message = this.message.slice();
+        const count: u32 = @sizeOf((u32)) + message.len + 1;
+        const header = [_]u8{
+            'f',
+        } ++ toBytes(Int32(count));
+        try writer.write(&header);
+        try writer.string(message);
+    }
+
+    pub const write = writeWrap(@This(), writeInternal).write;
+};
+
+pub const CopyInResponse = struct {
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        _ = reader;
+        _ = this;
+        TODO(@This());
+    }
+
+    pub const decode = decoderWrap(CopyInResponse, decodeInternal).decode;
+};
+
+pub const CopyOutResponse = struct {
+    pub fn decodeInternal(this: *@This(), comptime Container: type, reader: NewReader(Container)) !void {
+        _ = reader;
+        _ = this;
+        TODO(@This());
+    }
+
+    pub const decode = decoderWrap(CopyInResponse, decodeInternal).decode;
+};
+
+fn TODO(comptime Type: type) !void {
+    bun.Output.panic("TODO: not implemented {s}", .{bun.meta.typeBaseName(@typeName(Type))});
+}
diff --git a/src/sql/postgres/postgres_types.zig b/src/sql/postgres/postgres_types.zig
new file mode 100644
index 00000000000000..6a595cafb781e8
--- /dev/null
+++ b/src/sql/postgres/postgres_types.zig
@@ -0,0 +1,559 @@
+const std = @import("std");
+const bun = @import("root").bun;
+const postgres = bun.JSC.Postgres;
+const Data = postgres.Data;
+const protocol = @This();
+const PostgresInt32 = postgres.PostgresInt32;
+const PostgresShort = postgres.PostgresShort;
+const String = bun.String;
+const debug = postgres.debug;
+const Crypto = JSC.API.Bun.Crypto;
+const JSValue = JSC.JSValue;
+const JSC = bun.JSC;
+const short = postgres.short;
+const int4 = postgres.int4;
+
+//     select b.typname,  b.oid, b.typarray
+//       from pg_catalog.pg_type a
+//       left join pg_catalog.pg_type b on b.oid = a.typelem
+//       where a.typcategory = 'A'
+//       group by b.oid, b.typarray
+//       order by b.oid
+// ;
+//                 typname                |  oid  | typarray
+// ---------------------------------------+-------+----------
+//  bool                                  |    16 |     1000
+//  bytea                                 |    17 |     1001
+//  char                                  |    18 |     1002
+//  name                                  |    19 |     1003
+//  int8                                  |    20 |     1016
+//  int2                                  |    21 |     1005
+//  int2vector                            |    22 |     1006
+//  int4                                  |    23 |     1007
+//  regproc                               |    24 |     1008
+//  text                                  |    25 |     1009
+//  oid                                   |    26 |     1028
+//  tid                                   |    27 |     1010
+//  xid                                   |    28 |     1011
+//  cid                                   |    29 |     1012
+//  oidvector                             |    30 |     1013
+//  pg_type                               |    71 |      210
+//  pg_attribute                          |    75 |      270
+//  pg_proc                               |    81 |      272
+//  pg_class                              |    83 |      273
+//  json                                  |   114 |      199
+//  xml                                   |   142 |      143
+//  point                                 |   600 |     1017
+//  lseg                                  |   601 |     1018
+//  path                                  |   602 |     1019
+//  box                                   |   603 |     1020
+//  polygon                               |   604 |     1027
+//  line                                  |   628 |      629
+//  cidr                                  |   650 |      651
+//  float4                                |   700 |     1021
+//  float8                                |   701 |     1022
+//  circle                                |   718 |      719
+//  macaddr8                              |   774 |      775
+//  money                                 |   790 |      791
+//  macaddr                               |   829 |     1040
+//  inet                                  |   869 |     1041
+//  aclitem                               |  1033 |     1034
+//  bpchar                                |  1042 |     1014
+//  varchar                               |  1043 |     1015
+//  date                                  |  1082 |     1182
+//  time                                  |  1083 |     1183
+//  timestamp                             |  1114 |     1115
+//  timestamptz                           |  1184 |     1185
+//  interval                              |  1186 |     1187
+//  pg_database                           |  1248 |    12052
+//  timetz                                |  1266 |     1270
+//  bit                                   |  1560 |     1561
+//  varbit                                |  1562 |     1563
+//  numeric                               |  1700 |     1231
+pub const Tag = enum(short) {
+    bool = 16,
+    bytea = 17,
+    char = 18,
+    name = 19,
+    int8 = 20,
+    int2 = 21,
+    int2vector = 22,
+    int4 = 23,
+    // regproc = 24,
+    text = 25,
+    // oid = 26,
+    // tid = 27,
+    // xid = 28,
+    // cid = 29,
+    // oidvector = 30,
+    // pg_type = 71,
+    // pg_attribute = 75,
+    // pg_proc = 81,
+    // pg_class = 83,
+    json = 114,
+    xml = 142,
+    point = 600,
+    lseg = 601,
+    path = 602,
+    box = 603,
+    polygon = 604,
+    line = 628,
+    cidr = 650,
+    float4 = 700,
+    float8 = 701,
+    circle = 718,
+    macaddr8 = 774,
+    money = 790,
+    macaddr = 829,
+    inet = 869,
+    aclitem = 1033,
+    bpchar = 1042,
+    varchar = 1043,
+    date = 1082,
+    time = 1083,
+    timestamp = 1114,
+    timestamptz = 1184,
+    interval = 1186,
+    pg_database = 1248,
+    timetz = 1266,
+    bit = 1560,
+    varbit = 1562,
+    numeric = 1700,
+    uuid = 2950,
+
+    bool_array = 1000,
+    bytea_array = 1001,
+    char_array = 1002,
+    name_array = 1003,
+    int8_array = 1016,
+    int2_array = 1005,
+    int2vector_array = 1006,
+    int4_array = 1007,
+    // regproc_array = 1008,
+    text_array = 1009,
+    oid_array = 1028,
+    tid_array = 1010,
+    xid_array = 1011,
+    cid_array = 1012,
+    // oidvector_array = 1013,
+    // pg_type_array = 210,
+    // pg_attribute_array = 270,
+    // pg_proc_array = 272,
+    // pg_class_array = 273,
+    json_array = 199,
+    xml_array = 143,
+    point_array = 1017,
+    lseg_array = 1018,
+    path_array = 1019,
+    box_array = 1020,
+    polygon_array = 1027,
+    line_array = 629,
+    cidr_array = 651,
+    float4_array = 1021,
+    float8_array = 1022,
+    circle_array = 719,
+    macaddr8_array = 775,
+    money_array = 791,
+    macaddr_array = 1040,
+    inet_array = 1041,
+    aclitem_array = 1034,
+    bpchar_array = 1014,
+    varchar_array = 1015,
+    date_array = 1182,
+    time_array = 1183,
+    timestamp_array = 1115,
+    timestamptz_array = 1185,
+    interval_array = 1187,
+    pg_database_array = 12052,
+    timetz_array = 1270,
+    bit_array = 1561,
+    varbit_array = 1563,
+    numeric_array = 1231,
+    _,
+
+    pub fn isBinaryFormatSupported(this: Tag) bool {
+        return switch (this) {
+            // TODO: .int2_array, .float8_array,
+            .bool, .timestamp, .timestamptz, .time, .int4_array, .float4_array, .int4, .float8, .float4, .bytea, .numeric => true,
+
+            else => false,
+        };
+    }
+
+    pub fn formatCode(this: Tag) short {
+        if (this.isBinaryFormatSupported()) {
+            return 1;
+        }
+
+        return 0;
+    }
+
+    fn PostgresBinarySingleDimensionArray(comptime T: type) type {
+        return extern struct {
+            // struct array_int4 {
+            //   int4_t ndim; /* Number of dimensions */
+            //   int4_t _ign; /* offset for data, removed by libpq */
+            //   Oid elemtype; /* type of element in the array */
+
+            //   /* First dimension */
+            //   int4_t size; /* Number of elements */
+            //   int4_t index; /* Index of first element */
+            //   int4_t first_value; /* Beginning of integer data */
+            // };
+
+            ndim: i32,
+            offset_for_data: i32,
+            element_type: i32,
+
+            len: i32,
+            index: i32,
+            first_value: T,
+
+            pub fn slice(this: *@This()) []T {
+                if (this.len == 0) return &.{};
+
+                var head = @as([*]T, @ptrCast(&this.first_value));
+                var current = head;
+                const len: usize = @intCast(this.len);
+                for (0..len) |i| {
+                    // Skip every other value as it contains the size of the element
+                    current = current[1..];
+
+                    const val = current[0];
+                    const Int = std.meta.Int(.unsigned, @bitSizeOf(T));
+                    const swapped = @byteSwap(@as(Int, @bitCast(val)));
+
+                    head[i] = @bitCast(swapped);
+
+                    current = current[1..];
+                }
+
+                return head[0..len];
+            }
+
+            pub fn init(bytes: []const u8) *@This() {
+                const this: *@This() = @alignCast(@ptrCast(@constCast(bytes.ptr)));
+                this.ndim = @byteSwap(this.ndim);
+                this.offset_for_data = @byteSwap(this.offset_for_data);
+                this.element_type = @byteSwap(this.element_type);
+                this.len = @byteSwap(this.len);
+                this.index = @byteSwap(this.index);
+                return this;
+            }
+        };
+    }
+
+    pub fn toJSTypedArrayType(comptime T: Tag) JSValue.JSType {
+        return comptime switch (T) {
+            .int4_array => .Int32Array,
+            // .int2_array => .Uint2Array,
+            .float4_array => .Float32Array,
+            // .float8_array => .Float64Array,
+            else => @compileError("TODO: not implemented"),
+        };
+    }
+
+    pub fn byteArrayType(comptime T: Tag) type {
+        return comptime switch (T) {
+            .int4_array => i32,
+            // .int2_array => i16,
+            .float4_array => f32,
+            // .float8_array => f64,
+            else => @compileError("TODO: not implemented"),
+        };
+    }
+
+    pub fn unsignedByteArrayType(comptime T: Tag) type {
+        return comptime switch (T) {
+            .int4_array => u32,
+            // .int2_array => u16,
+            .float4_array => f32,
+            // .float8_array => f64,
+            else => @compileError("TODO: not implemented"),
+        };
+    }
+
+    pub fn pgArrayType(comptime T: Tag) type {
+        return PostgresBinarySingleDimensionArray(byteArrayType(T));
+    }
+
+    fn toJSWithType(
+        tag: Tag,
+        globalObject: *JSC.JSGlobalObject,
+        comptime Type: type,
+        value: Type,
+    ) anyerror!JSValue {
+        switch (tag) {
+            .numeric => {
+                return numeric.toJS(globalObject, value);
+            },
+
+            .float4, .float8 => {
+                return numeric.toJS(globalObject, value);
+            },
+
+            .json => {
+                return json.toJS(globalObject, value);
+            },
+
+            .bool => {
+                return @"bool".toJS(globalObject, value);
+            },
+
+            .timestamp, .timestamptz => {
+                return date.toJS(globalObject, value);
+            },
+
+            .bytea => {
+                return bytea.toJS(globalObject, value);
+            },
+
+            .int8 => {
+                return JSValue.fromInt64NoTruncate(globalObject, value);
+            },
+
+            .int4 => {
+                return numeric.toJS(globalObject, value);
+            },
+
+            else => {
+                return string.toJS(globalObject, value);
+            },
+        }
+    }
+
+    pub fn toJS(
+        tag: Tag,
+        globalObject: *JSC.JSGlobalObject,
+        value: anytype,
+    ) anyerror!JSValue {
+        return toJSWithType(tag, globalObject, @TypeOf(value), value);
+    }
+
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, value: JSValue) bun.JSError!Tag {
+        if (value.isEmptyOrUndefinedOrNull()) {
+            return Tag.numeric;
+        }
+
+        if (value.isCell()) {
+            const tag = value.jsType();
+            if (tag.isStringLike()) {
+                return .text;
+            }
+
+            if (tag == .JSDate) {
+                return .timestamptz;
+            }
+
+            if (tag.isTypedArray()) {
+                if (tag == .Int32Array)
+                    return .int4_array;
+
+                return .bytea;
+            }
+
+            if (tag == .HeapBigInt) {
+                return .int8;
+            }
+
+            if (tag.isArrayLike() and value.getLength(globalObject) > 0) {
+                return Tag.fromJS(globalObject, value.getIndex(globalObject, 0));
+            }
+            if (globalObject.hasException()) return error.JSError;
+
+            // Ban these types:
+            if (tag == .NumberObject) {
+                return error.JSError;
+            }
+
+            if (tag == .BooleanObject) {
+                return error.JSError;
+            }
+
+            // It's something internal
+            if (!tag.isIndexable()) {
+                return error.JSError;
+            }
+
+            // We will JSON.stringify anything else.
+            if (tag.isObject()) {
+                return .json;
+            }
+        }
+
+        if (value.isInt32()) {
+            return .int4;
+        }
+
+        if (value.isAnyInt()) {
+            const int = value.toInt64();
+            if (int >= std.math.minInt(u32) and int <= std.math.maxInt(u32)) {
+                return .int4;
+            }
+
+            return .int8;
+        }
+
+        if (value.isNumber()) {
+            return .float8;
+        }
+
+        if (value.isBoolean()) {
+            return .bool;
+        }
+
+        return .numeric;
+    }
+};
+
+pub const string = struct {
+    pub const to = 25;
+    pub const from = [_]short{1002};
+
+    pub fn toJSWithType(
+        globalThis: *JSC.JSGlobalObject,
+        comptime Type: type,
+        value: Type,
+    ) anyerror!JSValue {
+        switch (comptime Type) {
+            [:0]u8, []u8, []const u8, [:0]const u8 => {
+                var str = String.fromUTF8(value);
+                defer str.deinit();
+                return str.toJS(globalThis);
+            },
+
+            bun.String => {
+                return value.toJS(globalThis);
+            },
+
+            *Data => {
+                var str = String.fromUTF8(value.slice());
+                defer str.deinit();
+                defer value.deinit();
+                return str.toJS(globalThis);
+            },
+
+            else => {
+                @compileError("unsupported type " ++ @typeName(Type));
+            },
+        }
+    }
+
+    pub fn toJS(
+        globalThis: *JSC.JSGlobalObject,
+        value: anytype,
+    ) !JSValue {
+        var str = try toJSWithType(globalThis, @TypeOf(value), value);
+        defer str.deinit();
+        return str.toJS(globalThis);
+    }
+};
+
+pub const numeric = struct {
+    pub const to = 0;
+    pub const from = [_]short{ 21, 23, 26, 700, 701 };
+
+    pub fn toJS(
+        _: *JSC.JSGlobalObject,
+        value: anytype,
+    ) anyerror!JSValue {
+        return JSValue.jsNumber(value);
+    }
+};
+
+pub const json = struct {
+    pub const to = 114;
+    pub const from = [_]short{ 114, 3802 };
+
+    pub fn toJS(
+        globalObject: *JSC.JSGlobalObject,
+        value: *Data,
+    ) anyerror!JSValue {
+        defer value.deinit();
+        var str = bun.String.fromUTF8(value.slice());
+        defer str.deref();
+        const parse_result = JSValue.parse(str.toJS(globalObject), globalObject);
+        if (parse_result.isAnyError()) {
+            globalObject.throwValue(parse_result);
+            return error.JSError;
+        }
+
+        return parse_result;
+    }
+};
+
+pub const @"bool" = struct {
+    pub const to = 16;
+    pub const from = [_]short{16};
+
+    pub fn toJS(
+        _: *JSC.JSGlobalObject,
+        value: bool,
+    ) anyerror!JSValue {
+        return JSValue.jsBoolean(value);
+    }
+};
+
+pub const date = struct {
+    pub const to = 1184;
+    pub const from = [_]short{ 1082, 1114, 1184 };
+
+    // Postgres stores timestamp and timestampz as microseconds since 2000-01-01
+    // This is a signed 64-bit integer.
+    const POSTGRES_EPOCH_DATE = 946684800000;
+
+    pub fn fromBinary(bytes: []const u8) f64 {
+        const microseconds = std.mem.readInt(i64, bytes[0..8], .big);
+        const double_microseconds: f64 = @floatFromInt(microseconds);
+        return (double_microseconds / std.time.us_per_ms) + POSTGRES_EPOCH_DATE;
+    }
+
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, value: JSValue) i64 {
+        const double_value = if (value.isDate())
+            value.getUnixTimestamp()
+        else if (value.isNumber())
+            value.asNumber()
+        else if (value.isString()) brk: {
+            var str = value.toBunString(globalObject);
+            defer str.deref();
+            break :brk str.parseDate(globalObject);
+        } else return 0;
+
+        const unix_timestamp: i64 = @intFromFloat(double_value);
+        return (unix_timestamp - POSTGRES_EPOCH_DATE) * std.time.us_per_ms;
+    }
+
+    pub fn toJS(
+        globalObject: *JSC.JSGlobalObject,
+        value: anytype,
+    ) JSValue {
+        switch (@TypeOf(value)) {
+            i64 => {
+                // Convert from Postgres timestamp (μs since 2000-01-01) to Unix timestamp (ms)
+                const ms = @divFloor(value, std.time.us_per_ms) + POSTGRES_EPOCH_DATE;
+                return JSValue.fromDateNumber(globalObject, @floatFromInt(ms));
+            },
+            *Data => {
+                defer value.deinit();
+                return JSValue.fromDateString(globalObject, value.sliceZ().ptr);
+            },
+            else => @compileError("unsupported type " ++ @typeName(@TypeOf(value))),
+        }
+    }
+};
+
+pub const bytea = struct {
+    pub const to = 17;
+    pub const from = [_]short{17};
+
+    pub fn toJS(
+        globalObject: *JSC.JSGlobalObject,
+        value: *Data,
+    ) anyerror!JSValue {
+        defer value.deinit();
+
+        // var slice = value.slice()[@min(1, value.len)..];
+        // _ = slice;
+        return JSValue.createBuffer(globalObject, value.slice(), null);
+    }
+};
diff --git a/src/string.zig b/src/string.zig
index 2c694efbdddfba..eba63664aa5f03 100644
--- a/src/string.zig
+++ b/src/string.zig
@@ -691,6 +691,7 @@ pub const String = extern struct {
         try self.toZigString().format(fmt, opts, writer);
     }
 
+    /// Deprecated: use `fromJS2` to handle errors explicitly
     pub fn fromJS(value: bun.JSC.JSValue, globalObject: *JSC.JSGlobalObject) String {
         JSC.markBinding(@src());
 
@@ -702,14 +703,26 @@ pub const String = extern struct {
         }
     }
 
-    pub fn fromJSRef(value: bun.JSC.JSValue, globalObject: *JSC.JSGlobalObject) String {
+    pub fn fromJS2(value: bun.JSC.JSValue, globalObject: *JSC.JSGlobalObject) bun.JSError!String {
+        var out: String = String.dead;
+        if (BunString__fromJS(globalObject, value, &out)) {
+            bun.assert(out.tag != .Dead);
+            return out;
+        } else {
+            bun.assert(globalObject.hasException());
+            return error.JSError;
+        }
+    }
+
+    pub fn fromJSRef(value: bun.JSC.JSValue, globalObject: *JSC.JSGlobalObject) bun.JSError!String {
         JSC.markBinding(@src());
 
         var out: String = String.dead;
         if (BunString__fromJSRef(globalObject, value, &out)) {
             return out;
         } else {
-            return String.dead;
+            bun.assert(globalObject.hasException());
+            return error.JSError;
         }
     }
 
@@ -720,7 +733,7 @@ pub const String = extern struct {
         if (BunString__fromJS(globalObject, value, &out)) {
             return out;
         } else {
-            return null;
+            return null; //TODO: return error.JSError
         }
     }
 
@@ -1314,7 +1327,7 @@ pub const String = extern struct {
         return try concat(strings.len, allocator, strings);
     }
 
-    pub export fn jsGetStringWidth(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) callconv(JSC.conv) JSC.JSValue {
+    pub fn jsGetStringWidth(globalObject: *JSC.JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
         const args = callFrame.arguments(1).slice();
 
         if (args.len == 0 or !args.ptr[0].isString()) {
@@ -1331,6 +1344,11 @@ pub const String = extern struct {
         const width = str.visibleWidth(false);
         return JSC.jsNumber(width);
     }
+
+    // TODO: move ZigString.Slice here
+    /// A UTF-8 encoded slice tied to the lifetime of a `bun.String`
+    /// Must call `.deinit` to release memory
+    pub const Slice = ZigString.Slice;
 };
 
 pub const SliceWithUnderlyingString = struct {
diff --git a/src/string_immutable.zig b/src/string_immutable.zig
index d62af2b977cfa0..4ffa1e05a282cd 100644
--- a/src/string_immutable.zig
+++ b/src/string_immutable.zig
@@ -2152,6 +2152,20 @@ pub fn convertUTF16ToUTF8(list_: std.ArrayList(u8), comptime Type: type, utf16:
     return list;
 }
 
+pub fn convertUTF16ToUTF8WithoutInvalidSurrogatePairs(list_: std.ArrayList(u8), comptime Type: type, utf16: Type) !std.ArrayList(u8) {
+    var list = list_;
+    const result = bun.simdutf.convert.utf16.to.utf8.with_errors.le(
+        utf16,
+        list.items.ptr[0..list.capacity],
+    );
+    if (result.status == .surrogate) {
+        return error.SurrogatePair;
+    }
+
+    list.items.len = result.count;
+    return list;
+}
+
 pub fn convertUTF16ToUTF8Append(list: *std.ArrayList(u8), utf16: []const u16) !void {
     const result = bun.simdutf.convert.utf16.to.utf8.with_errors.le(
         utf16,
@@ -2167,6 +2181,20 @@ pub fn convertUTF16ToUTF8Append(list: *std.ArrayList(u8), utf16: []const u16) !v
     list.items.len += result.count;
 }
 
+pub fn toUTF8AllocWithTypeWithoutInvalidSurrogatePairs(allocator: std.mem.Allocator, comptime Type: type, utf16: Type) ![]u8 {
+    if (bun.FeatureFlags.use_simdutf and comptime Type == []const u16) {
+        const length = bun.simdutf.length.utf8.from.utf16.le(utf16);
+        // add 16 bytes of padding for SIMDUTF
+        var list = try std.ArrayList(u8).initCapacity(allocator, length + 16);
+        list = try convertUTF16ToUTF8(list, Type, utf16);
+        return list.items;
+    }
+
+    var list = try std.ArrayList(u8).initCapacity(allocator, utf16.len);
+    list = try toUTF8ListWithType(list, Type, utf16);
+    return list.items;
+}
+
 pub fn toUTF8AllocWithType(allocator: std.mem.Allocator, comptime Type: type, utf16: Type) ![]u8 {
     if (bun.FeatureFlags.use_simdutf and comptime Type == []const u16) {
         const length = bun.simdutf.length.utf8.from.utf16.le(utf16);
@@ -4230,21 +4258,30 @@ pub fn containsNewlineOrNonASCIIOrQuote(slice_: []const u8) bool {
     return false;
 }
 
-pub fn indexOfNeedsEscape(slice: []const u8) ?u32 {
+pub fn indexOfNeedsEscape(slice: []const u8, comptime quote_char: u8) ?u32 {
     var remaining = slice;
     if (remaining.len == 0)
         return null;
 
-    if (remaining[0] >= 127 or remaining[0] < 0x20 or remaining[0] == '\\' or remaining[0] == '"') {
+    if (remaining[0] >= 127 or remaining[0] < 0x20 or remaining[0] == '\\' or remaining[0] == quote_char or (quote_char == '`' and remaining[0] == '$')) {
         return 0;
     }
 
     if (comptime Environment.enableSIMD) {
         while (remaining.len >= ascii_vector_size) {
             const vec: AsciiVector = remaining[0..ascii_vector_size].*;
-            const cmp = @as(AsciiVectorU1, @bitCast((vec > max_16_ascii))) | @as(AsciiVectorU1, @bitCast((vec < min_16_ascii))) |
+            const cmp: AsciiVectorU1 = if (comptime quote_char == '`') ( //
+                @as(AsciiVectorU1, @bitCast((vec > max_16_ascii))) |
+                @as(AsciiVectorU1, @bitCast((vec < min_16_ascii))) |
                 @as(AsciiVectorU1, @bitCast(vec == @as(AsciiVector, @splat(@as(u8, '\\'))))) |
-                @as(AsciiVectorU1, @bitCast(vec == @as(AsciiVector, @splat(@as(u8, '"')))));
+                @as(AsciiVectorU1, @bitCast(vec == @as(AsciiVector, @splat(@as(u8, quote_char))))) |
+                @as(AsciiVectorU1, @bitCast(vec == @as(AsciiVector, @splat(@as(u8, '$'))))) //
+            ) else ( //
+                @as(AsciiVectorU1, @bitCast((vec > max_16_ascii))) |
+                @as(AsciiVectorU1, @bitCast((vec < min_16_ascii))) |
+                @as(AsciiVectorU1, @bitCast(vec == @as(AsciiVector, @splat(@as(u8, '\\'))))) |
+                @as(AsciiVectorU1, @bitCast(vec == @as(AsciiVector, @splat(@as(u8, quote_char))))) //
+            );
 
             if (@reduce(.Max, cmp) > 0) {
                 const bitmask = @as(AsciiVectorInt, @bitCast(cmp));
@@ -4259,7 +4296,7 @@ pub fn indexOfNeedsEscape(slice: []const u8) ?u32 {
 
     for (remaining) |*char_| {
         const char = char_.*;
-        if (char > 127 or char < 0x20 or char == '\\' or char == '"') {
+        if (char > 127 or char < 0x20 or char == '\\' or char == quote_char or (quote_char == '`' and char == '$')) {
             return @as(u32, @truncate(@intFromPtr(char_) - @intFromPtr(slice.ptr)));
         }
     }
@@ -4299,6 +4336,27 @@ pub fn indexOfCharUsize(slice: []const u8, char: u8) ?usize {
     return i;
 }
 
+pub fn indexOfCharPos(slice: []const u8, char: u8, start_index: usize) ?usize {
+    if (!Environment.isNative) {
+        return std.mem.indexOfScalarPos(u8, slice, char);
+    }
+
+    if (start_index >= slice.len) return null;
+
+    const ptr = bun.C.memchr(slice.ptr + start_index, char, slice.len - start_index) orelse
+        return null;
+    const i = @intFromPtr(ptr) - @intFromPtr(slice.ptr);
+    bun.assert(i < slice.len);
+    bun.assert(slice[i] == char);
+
+    return i;
+}
+
+pub fn indexOfAnyPosComptime(slice: []const u8, comptime chars: []const u8, start_index: usize) ?usize {
+    if (chars.len == 1) return indexOfCharPos(slice, chars[0], start_index);
+    return std.mem.indexOfAnyPos(u8, slice, start_index, chars);
+}
+
 pub fn indexOfChar16Usize(slice: []const u16, char: u16) ?usize {
     return std.mem.indexOfScalar(u16, slice, char);
 }
diff --git a/src/sys.zig b/src/sys.zig
index e6d9eec837551d..de27a70a0a0519 100644
--- a/src/sys.zig
+++ b/src/sys.zig
@@ -11,8 +11,8 @@ const default_allocator = bun.default_allocator;
 const kernel32 = bun.windows;
 const mem = std.mem;
 const mode_t = posix.mode_t;
-const open_sym = system.open;
-const sys = std.posix.system;
+const libc = std.posix.system;
+
 const windows = bun.windows;
 
 const C = bun.C;
@@ -23,16 +23,20 @@ const PathString = bun.PathString;
 const Syscall = @This();
 const SystemError = JSC.SystemError;
 
-const linux = system;
+const linux = syscall;
 
 pub const sys_uv = if (Environment.isWindows) @import("./sys_uv.zig") else Syscall;
 
 const log = bun.Output.scoped(.SYS, false);
 pub const syslog = log;
 
-pub const system = switch (Environment.os) {
+pub const syscall = switch (Environment.os) {
     .linux => std.os.linux,
+
+    // This is actually libc on MacOS
+    // We don't directly use the Darwin syscall interface.
     .mac => bun.AsyncIO.system,
+
     else => @compileError("not implemented"),
 };
 
@@ -297,17 +301,17 @@ pub const Error = struct {
         return copy;
     }
 
-    pub fn fromCode(errno: E, syscall: Syscall.Tag) Error {
+    pub fn fromCode(errno: E, syscall_tag: Syscall.Tag) Error {
         return .{
             .errno = @as(Int, @intCast(@intFromEnum(errno))),
-            .syscall = syscall,
+            .syscall = syscall_tag,
         };
     }
 
-    pub fn fromCodeInt(errno: anytype, syscall: Syscall.Tag) Error {
+    pub fn fromCodeInt(errno: anytype, syscall_tag: Syscall.Tag) Error {
         return .{
             .errno = @as(Int, @intCast(if (Environment.isWindows) @abs(errno) else errno)),
-            .syscall = syscall,
+            .syscall = syscall_tag,
         };
     }
 
@@ -435,7 +439,7 @@ pub const Error = struct {
     }
 
     pub fn toJS(this: Error, ctx: JSC.C.JSContextRef) JSC.C.JSObjectRef {
-        return this.toSystemError().toErrorInstance(ctx.ptr()).asObjectRef();
+        return this.toSystemError().toErrorInstance(ctx).asObjectRef();
     }
 
     pub fn toJSC(this: Error, ptr: *JSC.JSGlobalObject) JSC.JSValue {
@@ -502,7 +506,7 @@ pub fn chdirOSPath(destination: bun.OSPathSliceZ) Maybe(void) {
     assertIsValidWindowsPath(bun.OSPathChar, destination);
 
     if (comptime Environment.isPosix) {
-        const rc = sys.chdir(destination);
+        const rc = syscall.chdir(destination);
         return Maybe(void).errnoSys(rc, .chdir) orelse Maybe(void).success;
     }
 
@@ -626,7 +630,7 @@ pub fn mkdiratA(dir_fd: bun.FileDescriptor, file_path: []const u8) Maybe(void) {
 
 pub fn mkdiratZ(dir_fd: bun.FileDescriptor, file_path: [*:0]const u8, mode: mode_t) Maybe(void) {
     return switch (Environment.os) {
-        .mac => Maybe(void).errnoSysP(system.mkdirat(@intCast(dir_fd.cast()), file_path, mode), .mkdir, file_path) orelse Maybe(void).success,
+        .mac => Maybe(void).errnoSysP(syscall.mkdirat(@intCast(dir_fd.cast()), file_path, mode), .mkdir, file_path) orelse Maybe(void).success,
         .linux => Maybe(void).errnoSysP(linux.mkdirat(@intCast(dir_fd.cast()), file_path, mode), .mkdir, file_path) orelse Maybe(void).success,
         else => @compileError("mkdir is not implemented on this platform"),
     };
@@ -667,7 +671,7 @@ pub fn fstatat(fd: bun.FileDescriptor, path: [:0]const u8) Maybe(bun.Stat) {
         };
     }
     var stat_ = mem.zeroes(bun.Stat);
-    if (Maybe(bun.Stat).errnoSys(sys.fstatat(fd.int(), path, &stat_, 0), .fstatat)) |err| {
+    if (Maybe(bun.Stat).errnoSys(syscall.fstatat(fd.int(), path, &stat_, 0), .fstatat)) |err| {
         log("fstatat({}, {s}) = {s}", .{ fd, path, @tagName(err.getErrno()) });
         return err;
     }
@@ -677,9 +681,9 @@ pub fn fstatat(fd: bun.FileDescriptor, path: [:0]const u8) Maybe(bun.Stat) {
 
 pub fn mkdir(file_path: [:0]const u8, flags: bun.Mode) Maybe(void) {
     return switch (Environment.os) {
-        .mac => Maybe(void).errnoSysP(system.mkdir(file_path, flags), .mkdir, file_path) orelse Maybe(void).success,
+        .mac => Maybe(void).errnoSysP(syscall.mkdir(file_path, flags), .mkdir, file_path) orelse Maybe(void).success,
 
-        .linux => Maybe(void).errnoSysP(system.mkdir(file_path, flags), .mkdir, file_path) orelse Maybe(void).success,
+        .linux => Maybe(void).errnoSysP(syscall.mkdir(file_path, flags), .mkdir, file_path) orelse Maybe(void).success,
 
         .windows => {
             var wbuf: bun.WPathBuffer = undefined;
@@ -696,7 +700,7 @@ pub fn mkdir(file_path: [:0]const u8, flags: bun.Mode) Maybe(void) {
 
 pub fn mkdirA(file_path: []const u8, flags: bun.Mode) Maybe(void) {
     if (comptime Environment.isMac) {
-        return Maybe(void).errnoSysP(system.mkdir(&(std.posix.toPosixPath(file_path) catch return Maybe(void){
+        return Maybe(void).errnoSysP(syscall.mkdir(&(std.posix.toPosixPath(file_path) catch return Maybe(void){
             .err = .{
                 .errno = @intFromEnum(bun.C.E.NOMEM),
                 .syscall = .open,
@@ -1254,7 +1258,7 @@ pub fn openatWindowsA(
 pub fn openatOSPath(dirfd: bun.FileDescriptor, file_path: bun.OSPathSliceZ, flags: bun.Mode, perm: bun.Mode) Maybe(bun.FileDescriptor) {
     if (comptime Environment.isMac) {
         // https://opensource.apple.com/source/xnu/xnu-7195.81.3/libsyscall/wrappers/open-base.c
-        const rc = system.@"openat$NOCANCEL"(dirfd.cast(), file_path.ptr, @as(c_uint, @intCast(flags)), @as(c_int, @intCast(perm)));
+        const rc = syscall.@"openat$NOCANCEL"(dirfd.cast(), file_path.ptr, @as(c_uint, @intCast(flags)), @as(c_int, @intCast(perm)));
         if (comptime Environment.allow_assert)
             log("openat({}, {s}) = {d}", .{ dirfd, bun.sliceTo(file_path, 0), rc });
 
@@ -1264,7 +1268,7 @@ pub fn openatOSPath(dirfd: bun.FileDescriptor, file_path: bun.OSPathSliceZ, flag
     }
 
     while (true) {
-        const rc = Syscall.system.openat(dirfd.cast(), file_path, bun.O.toPacked(flags), perm);
+        const rc = syscall.openat(dirfd.cast(), file_path, bun.O.toPacked(flags), perm);
         if (comptime Environment.allow_assert)
             log("openat({}, {s}) = {d}", .{ dirfd, bun.sliceTo(file_path, 0), rc });
         return switch (Syscall.getErrno(rc)) {
@@ -1282,6 +1286,10 @@ pub fn openatOSPath(dirfd: bun.FileDescriptor, file_path: bun.OSPathSliceZ, flag
     }
 }
 
+pub fn access(path: bun.OSPathSliceZ, mode: bun.Mode) Maybe(void) {
+    return Maybe(void).errnoSysP(syscall.access(path, mode), .access, path) orelse .{ .result = {} };
+}
+
 pub fn openat(dirfd: bun.FileDescriptor, file_path: [:0]const u8, flags: bun.Mode, perm: bun.Mode) Maybe(bun.FileDescriptor) {
     if (comptime Environment.isWindows) {
         return openatWindowsT(u8, dirfd, file_path, flags);
@@ -1364,7 +1372,7 @@ pub fn write(fd: bun.FileDescriptor, bytes: []const u8) Maybe(usize) {
 
     return switch (Environment.os) {
         .mac => {
-            const rc = system.@"write$NOCANCEL"(fd.cast(), bytes.ptr, adjusted_len);
+            const rc = syscall.@"write$NOCANCEL"(fd.cast(), bytes.ptr, adjusted_len);
             log("write({}, {d}) = {d} ({})", .{ fd, adjusted_len, rc, debug_timer });
 
             if (Maybe(usize).errnoSysFd(rc, .write, fd)) |err| {
@@ -1375,7 +1383,7 @@ pub fn write(fd: bun.FileDescriptor, bytes: []const u8) Maybe(usize) {
         },
         .linux => {
             while (true) {
-                const rc = sys.write(fd.cast(), bytes.ptr, adjusted_len);
+                const rc = syscall.write(fd.cast(), bytes.ptr, adjusted_len);
                 log("write({}, {d}) = {d} {}", .{ fd, adjusted_len, rc, debug_timer });
 
                 if (Maybe(usize).errnoSysFd(rc, .write, fd)) |err| {
@@ -1554,39 +1562,35 @@ pub fn preadv(fd: bun.FileDescriptor, buffers: []std.posix.iovec, position: isiz
 const preadv_sym = if (builtin.os.tag == .linux and builtin.link_libc)
     std.os.linux.preadv
 else if (builtin.os.tag.isDarwin())
-    system.@"preadv$NOCANCEL"
+    syscall.@"preadv$NOCANCEL"
 else
-    system.preadv;
+    syscall.preadv;
 
 const readv_sym = if (builtin.os.tag == .linux and builtin.link_libc)
     std.os.linux.readv
 else if (builtin.os.tag.isDarwin())
-    system.@"readv$NOCANCEL"
+    syscall.@"readv$NOCANCEL"
 else
-    system.readv;
+    syscall.readv;
 
 const pwritev_sym = if (builtin.os.tag == .linux and builtin.link_libc)
     std.os.linux.pwritev
 else if (builtin.os.tag.isDarwin())
-    system.@"pwritev$NOCANCEL"
+    syscall.@"pwritev$NOCANCEL"
 else
-    system.pwritev;
+    syscall.pwritev;
 
-const writev_sym = if (builtin.os.tag == .linux and builtin.link_libc)
-    std.os.linux.writev
-else if (builtin.os.tag.isDarwin())
-    system.@"writev$NOCANCEL"
+const writev_sym = if (builtin.os.tag.isDarwin())
+    syscall.@"writev$NOCANCEL"
 else
-    system.writev;
+    syscall.writev;
 
-const pread_sym = if (builtin.os.tag == .linux and builtin.link_libc and !bun.Environment.isMusl)
-    sys.pread64
-else if (builtin.os.tag.isDarwin())
-    system.@"pread$NOCANCEL"
+const pread_sym = if (builtin.os.tag.isDarwin())
+    syscall.@"pread$NOCANCEL"
 else
-    system.pread;
+    syscall.pread;
 
-const fcntl_symbol = system.fcntl;
+const fcntl_symbol = syscall.fcntl;
 
 pub fn pread(fd: bun.FileDescriptor, buf: []u8, offset: i64) Maybe(usize) {
     const adjusted_len = @min(buf.len, max_count);
@@ -1609,9 +1613,9 @@ pub fn pread(fd: bun.FileDescriptor, buf: []u8, offset: i64) Maybe(usize) {
 }
 
 const pwrite_sym = if (builtin.os.tag == .linux and builtin.link_libc and !bun.Environment.isMusl)
-    sys.pwrite64
+    libc.pwrite64
 else
-    sys.pwrite;
+    syscall.pwrite;
 
 pub fn pwrite(fd: bun.FileDescriptor, bytes: []const u8, offset: i64) Maybe(usize) {
     if (comptime Environment.allow_assert) {
@@ -1644,7 +1648,7 @@ pub fn read(fd: bun.FileDescriptor, buf: []u8) Maybe(usize) {
     const adjusted_len = @min(buf.len, max_count);
     return switch (Environment.os) {
         .mac => {
-            const rc = system.@"read$NOCANCEL"(fd.cast(), buf.ptr, adjusted_len);
+            const rc = syscall.@"read$NOCANCEL"(fd.cast(), buf.ptr, adjusted_len);
 
             if (Maybe(usize).errnoSysFd(rc, .read, fd)) |err| {
                 log("read({}, {d}) = {s} ({any})", .{ fd, adjusted_len, err.err.name(), debug_timer });
@@ -1656,7 +1660,7 @@ pub fn read(fd: bun.FileDescriptor, buf: []u8) Maybe(usize) {
         },
         .linux => {
             while (true) {
-                const rc = sys.read(fd.cast(), buf.ptr, adjusted_len);
+                const rc = syscall.read(fd.cast(), buf.ptr, adjusted_len);
                 log("read({}, {d}) = {d} ({any})", .{ fd, adjusted_len, rc, debug_timer });
 
                 if (Maybe(usize).errnoSysFd(rc, .read, fd)) |err| {
@@ -1710,7 +1714,7 @@ pub fn recv(fd: bun.FileDescriptor, buf: []u8, flag: u32) Maybe(usize) {
     }
 
     if (comptime Environment.isMac) {
-        const rc = system.@"recvfrom$NOCANCEL"(fd.cast(), buf.ptr, adjusted_len, flag, null, null);
+        const rc = syscall.@"recvfrom$NOCANCEL"(fd.cast(), buf.ptr, adjusted_len, flag, null, null);
 
         if (Maybe(usize).errnoSys(rc, .recv)) |err| {
             log("recv({}, {d}) = {s} {}", .{ fd, adjusted_len, err.err.name(), debug_timer });
@@ -1741,7 +1745,7 @@ pub fn sendNonBlock(fd: bun.FileDescriptor, buf: []const u8) Maybe(usize) {
 
 pub fn send(fd: bun.FileDescriptor, buf: []const u8, flag: u32) Maybe(usize) {
     if (comptime Environment.isMac) {
-        const rc = system.@"sendto$NOCANCEL"(fd.cast(), buf.ptr, buf.len, flag, null, 0);
+        const rc = syscall.@"sendto$NOCANCEL"(fd.cast(), buf.ptr, buf.len, flag, null, 0);
 
         if (Maybe(usize).errnoSys(rc, .send)) |err| {
             syslog("send({}, {d}) = {s}", .{ fd, buf.len, err.err.name() });
@@ -1767,13 +1771,25 @@ pub fn send(fd: bun.FileDescriptor, buf: []const u8, flag: u32) Maybe(usize) {
     }
 }
 
+pub fn lseek(fd: bun.FileDescriptor, offset: i64, whence: usize) Maybe(usize) {
+    while (true) {
+        const rc = syscall.lseek(fd.cast(), offset, whence);
+        if (Maybe(usize).errnoSys(rc, .lseek)) |err| {
+            if (err.getErrno() == .INTR) continue;
+            return err;
+        }
+
+        return Maybe(usize){ .result = rc };
+    }
+}
+
 pub fn readlink(in: [:0]const u8, buf: []u8) Maybe([:0]u8) {
     if (comptime Environment.isWindows) {
         return sys_uv.readlink(in, buf);
     }
 
     while (true) {
-        const rc = sys.readlink(in, buf.ptr, buf.len);
+        const rc = syscall.readlink(in, buf.ptr, buf.len);
 
         if (Maybe([:0]u8).errnoSys(rc, .readlink)) |err| {
             if (err.getErrno() == .INTR) continue;
@@ -1784,16 +1800,16 @@ pub fn readlink(in: [:0]const u8, buf: []u8) Maybe([:0]u8) {
     }
 }
 
-pub fn readlinkat(fd: bun.FileDescriptor, in: [:0]const u8, buf: []u8) Maybe([:0]const u8) {
+pub fn readlinkat(fd: bun.FileDescriptor, in: [:0]const u8, buf: []u8) Maybe([:0]u8) {
     while (true) {
-        const rc = sys.readlinkat(fd.cast(), in, buf.ptr, buf.len);
+        const rc = syscall.readlinkat(fd.cast(), in, buf.ptr, buf.len);
 
-        if (Maybe([:0]const u8).errnoSys(rc, .readlink)) |err| {
+        if (Maybe([:0]u8).errnoSys(rc, .readlink)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
         buf[@intCast(rc)] = 0;
-        return Maybe([:0]const u8){ .result = buf[0..@intCast(rc) :0] };
+        return Maybe([:0]u8){ .result = buf[0..@intCast(rc) :0] };
     }
 }
 
@@ -1807,7 +1823,7 @@ pub fn ftruncate(fd: bun.FileDescriptor, size: isize) Maybe(void) {
     }
 
     return while (true) {
-        if (Maybe(void).errnoSys(sys.ftruncate(fd.cast(), size), .ftruncate)) |err| {
+        if (Maybe(void).errnoSys(syscall.ftruncate(fd.cast(), size), .ftruncate)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -1817,7 +1833,7 @@ pub fn ftruncate(fd: bun.FileDescriptor, size: isize) Maybe(void) {
 
 pub fn rename(from: [:0]const u8, to: [:0]const u8) Maybe(void) {
     while (true) {
-        if (Maybe(void).errnoSys(sys.rename(from, to), .rename)) |err| {
+        if (Maybe(void).errnoSys(syscall.rename(from, to), .rename)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -1963,7 +1979,7 @@ pub fn renameat(from_dir: bun.FileDescriptor, from: [:0]const u8, to_dir: bun.Fi
         return rc;
     }
     while (true) {
-        if (Maybe(void).errnoSys(sys.renameat(from_dir.cast(), from, to_dir.cast(), to), .rename)) |err| {
+        if (Maybe(void).errnoSys(syscall.renameat(from_dir.cast(), from, to_dir.cast(), to), .rename)) |err| {
             if (err.getErrno() == .INTR) continue;
             if (comptime Environment.allow_assert)
                 log("renameat({}, {s}, {}, {s}) = {d}", .{ from_dir, from, to_dir, to, @intFromEnum(err.getErrno()) });
@@ -1987,7 +2003,7 @@ pub fn chown(path: [:0]const u8, uid: posix.uid_t, gid: posix.gid_t) Maybe(void)
 
 pub fn symlink(target: [:0]const u8, dest: [:0]const u8) Maybe(void) {
     while (true) {
-        if (Maybe(void).errnoSys(sys.symlink(target, dest), .symlink)) |err| {
+        if (Maybe(void).errnoSys(syscall.symlink(target, dest), .symlink)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -1997,7 +2013,7 @@ pub fn symlink(target: [:0]const u8, dest: [:0]const u8) Maybe(void) {
 
 pub fn symlinkat(target: [:0]const u8, dirfd: bun.FileDescriptor, dest: [:0]const u8) Maybe(void) {
     while (true) {
-        if (Maybe(void).errnoSys(sys.symlinkat(target, dirfd.cast(), dest), .symlinkat)) |err| {
+        if (Maybe(void).errnoSys(syscall.symlinkat(target, dirfd.cast(), dest), .symlinkat)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -2120,7 +2136,7 @@ pub fn fcopyfile(fd_in: bun.FileDescriptor, fd_out: bun.FileDescriptor, flags: u
     if (comptime !Environment.isMac) @compileError("macOS only");
 
     while (true) {
-        if (Maybe(void).errnoSys(system.fcopyfile(fd_in.cast(), fd_out.cast(), null, flags), .fcopyfile)) |err| {
+        if (Maybe(void).errnoSys(syscall.fcopyfile(fd_in.cast(), fd_out.cast(), null, flags), .fcopyfile)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -2143,7 +2159,7 @@ pub fn unlink(from: [:0]const u8) Maybe(void) {
     }
 
     while (true) {
-        if (Maybe(void).errnoSys(sys.unlink(from), .unlink)) |err| {
+        if (Maybe(void).errnoSys(syscall.unlink(from), .unlink)) |err| {
             if (err.getErrno() == .INTR) continue;
             return err;
         }
@@ -2171,7 +2187,7 @@ pub fn unlinkatWithFlags(dirfd: bun.FileDescriptor, to: anytype, flags: c_uint)
     }
 
     while (true) {
-        if (Maybe(void).errnoSys(sys.unlinkat(dirfd.cast(), to, flags), .unlink)) |err| {
+        if (Maybe(void).errnoSys(syscall.unlinkat(dirfd.cast(), to, flags), .unlink)) |err| {
             if (err.getErrno() == .INTR) continue;
             if (comptime Environment.allow_assert)
                 log("unlinkat({}, {s}) = {d}", .{ dirfd, bun.sliceTo(to, 0), @intFromEnum(err.getErrno()) });
@@ -2189,7 +2205,7 @@ pub fn unlinkat(dirfd: bun.FileDescriptor, to: anytype) Maybe(void) {
         return unlinkatWithFlags(dirfd, to, 0);
     }
     while (true) {
-        if (Maybe(void).errnoSys(sys.unlinkat(dirfd.cast(), to, 0), .unlink)) |err| {
+        if (Maybe(void).errnoSys(syscall.unlinkat(dirfd.cast(), to, 0), .unlink)) |err| {
             if (err.getErrno() == .INTR) continue;
             if (comptime Environment.allow_assert)
                 log("unlinkat({}, {s}) = {d}", .{ dirfd, bun.sliceTo(to, 0), @intFromEnum(err.getErrno()) });
@@ -2216,7 +2232,7 @@ pub fn getFdPath(fd: bun.FileDescriptor, out_buffer: *[MAX_PATH_BYTES]u8) Maybe(
             // On macOS, we can use F.GETPATH fcntl command to query the OS for
             // the path to the file descriptor.
             @memset(out_buffer[0..MAX_PATH_BYTES], 0);
-            if (Maybe([]u8).errnoSys(system.fcntl(fd.cast(), posix.F.GETPATH, out_buffer), .fcntl)) |err| {
+            if (Maybe([]u8).errnoSys(syscall.fcntl(fd.cast(), posix.F.GETPATH, out_buffer), .fcntl)) |err| {
                 return err;
             }
             const len = mem.indexOfScalar(u8, out_buffer[0..], @as(u8, 0)) orelse MAX_PATH_BYTES;
@@ -2293,7 +2309,7 @@ pub fn mmapFile(path: [:0]const u8, flags: std.c.MAP, wanted_size: ?usize, offse
 }
 
 pub fn munmap(memory: []align(mem.page_size) const u8) Maybe(void) {
-    if (Maybe(void).errnoSys(system.munmap(memory.ptr, memory.len), .munmap)) |err| {
+    if (Maybe(void).errnoSys(syscall.munmap(memory.ptr, memory.len), .munmap)) |err| {
         return err;
     } else return Maybe(void).success;
 }
@@ -2456,7 +2472,7 @@ pub fn getFileAttributes(path: anytype) ?WindowsFileAttributes {
 
 pub fn existsOSPath(path: bun.OSPathSliceZ, file_only: bool) bool {
     if (comptime Environment.isPosix) {
-        return system.access(path, 0) == 0;
+        return syscall.access(path, 0) == 0;
     }
 
     if (comptime Environment.isWindows) {
@@ -2474,7 +2490,7 @@ pub fn existsOSPath(path: bun.OSPathSliceZ, file_only: bool) bool {
 
 pub fn exists(path: []const u8) bool {
     if (comptime Environment.isPosix) {
-        return system.access(&(std.posix.toPosixPath(path) catch return false), 0) == 0;
+        return syscall.access(&(std.posix.toPosixPath(path) catch return false), 0) == 0;
     }
 
     if (comptime Environment.isWindows) {
@@ -2486,7 +2502,7 @@ pub fn exists(path: []const u8) bool {
 
 pub fn existsZ(path: [:0]const u8) bool {
     if (comptime Environment.isPosix) {
-        return system.access(path, 0) == 0;
+        return syscall.access(path, 0) == 0;
     }
 
     if (comptime Environment.isWindows) {
@@ -2750,7 +2766,7 @@ pub fn pipe() Maybe([2]bun.FileDescriptor) {
     }
 
     var fds: [2]i32 = undefined;
-    const rc = system.pipe(&fds);
+    const rc = syscall.pipe(&fds);
     if (Maybe([2]bun.FileDescriptor).errnoSys(
         rc,
         .pipe,
@@ -2793,15 +2809,15 @@ pub fn dupWithFlags(fd: bun.FileDescriptor, flags: i32) Maybe(bun.FileDescriptor
     }
 
     const ArgType = if (comptime Environment.isLinux) usize else c_int;
-    const out = system.fcntl(fd.cast(), @as(i32, bun.C.F.DUPFD_CLOEXEC), @as(ArgType, 0));
+    const out = syscall.fcntl(fd.cast(), @as(i32, bun.C.F.DUPFD_CLOEXEC), @as(ArgType, 0));
     log("dup({d}) = {d}", .{ fd.cast(), out });
     if (Maybe(bun.FileDescriptor).errnoSysFd(out, .dup, fd)) |err| {
         return err;
     }
 
     if (flags != 0) {
-        const fd_flags: ArgType = @intCast(system.fcntl(@intCast(out), @as(i32, std.posix.F.GETFD), @as(ArgType, 0)));
-        _ = system.fcntl(@intCast(out), @as(i32, std.posix.F.SETFD), @as(ArgType, @intCast(fd_flags | @as(ArgType, @intCast(flags)))));
+        const fd_flags: ArgType = @intCast(syscall.fcntl(@intCast(out), @as(i32, std.posix.F.GETFD), @as(ArgType, 0)));
+        _ = syscall.fcntl(@intCast(out), @as(i32, std.posix.F.SETFD), @as(ArgType, @intCast(fd_flags | @as(ArgType, @intCast(flags)))));
     }
 
     return Maybe(bun.FileDescriptor){
@@ -3394,7 +3410,7 @@ pub const File = struct {
 
 pub inline fn toLibUVOwnedFD(
     maybe_windows_fd: bun.FileDescriptor,
-    comptime syscall: Syscall.Tag,
+    comptime syscall_tag: Syscall.Tag,
     comptime error_case: enum { close_on_fail, leak_fd_on_fail },
 ) Maybe(bun.FileDescriptor) {
     if (!Environment.isWindows) {
@@ -3410,7 +3426,7 @@ pub inline fn toLibUVOwnedFD(
                 return .{
                     .err = .{
                         .errno = @intFromEnum(bun.C.E.MFILE),
-                        .syscall = syscall,
+                        .syscall = syscall_tag,
                     },
                 };
             },
diff --git a/src/toml/toml_lexer.zig b/src/toml/toml_lexer.zig
index 34f3646de11871..5984f33d26cfc4 100644
--- a/src/toml/toml_lexer.zig
+++ b/src/toml/toml_lexer.zig
@@ -1184,7 +1184,7 @@ pub const Lexer = struct {
         }
 
         return js_ast.Expr.init(
-            js_ast.E.UTF8String,
+            js_ast.E.String,
             .{ .data = lexer.string_literal_slice },
             loc_,
         );
diff --git a/src/url.zig b/src/url.zig
index 38e3b6aab1f474..9cf7aee9f8ddad 100644
--- a/src/url.zig
+++ b/src/url.zig
@@ -977,10 +977,10 @@ pub const FormData = struct {
         }
     }
 
-    pub fn jsFunctionFromMultipartData(
+    pub fn fromMultipartData(
         globalThis: *JSC.JSGlobalObject,
         callframe: *JSC.CallFrame,
-    ) callconv(JSC.conv) JSC.JSValue {
+    ) bun.JSError!JSC.JSValue {
         JSC.markBinding(@src());
 
         const args_ = callframe.arguments(2);
@@ -1038,6 +1038,7 @@ pub const FormData = struct {
     }
 
     comptime {
+        const jsFunctionFromMultipartData = JSC.toJSHostFunction(fromMultipartData);
         if (!JSC.is_bindgen)
             @export(jsFunctionFromMultipartData, .{ .name = "FormData__jsFunctionFromMultipartData" });
     }
diff --git a/test/bake/framework-router.test.ts b/test/bake/framework-router.test.ts
new file mode 100644
index 00000000000000..5b2d2498f613aa
--- /dev/null
+++ b/test/bake/framework-router.test.ts
@@ -0,0 +1,63 @@
+import { describe, test } from "bun:test";
+import { frameworkRouterInternals } from 'bun:internal-for-testing';
+import { expect } from "bun:test";
+
+const { parseRoutePattern } = frameworkRouterInternals;
+
+const testRoutePattern = (style: string) => {
+  // The 'expected' is a one-off string serialization that is only used for testing.
+  // Params are serialized as ":param", catch all as ":*param", and optional catch all as ":*?param".
+  const fn = (pattern:string, expected:string, kind: 'page' | 'layout' | 'extra'= 'page') => {
+    test(`[${style}] should pass: ${JSON.stringify(pattern)})`, () => {
+      const result = parseRoutePattern(style, pattern);
+      expect(result.kind, 'expected route kind to match').toBe(kind);
+      expect(result.pattern, 'expected route pattern to match').toBe(expected);
+    }); 
+  }
+  fn.fails = (pattern: string, msg: string) => {
+    test(`[${style}] should error: ${JSON.stringify(pattern)})`, () => {
+      expect(() => parseRoutePattern(style, pattern)).toThrow(msg);
+    });
+  }
+  return fn;
+};
+
+describe("route pattern parser", () => {
+  const testPages = testRoutePattern('nextjs-pages-ui');
+  testPages('/index.tsx', '', 'page');
+  testPages('/_layout.tsx', '', 'layout');
+  testPages('/subdir/index.tsx', '/subdir', 'page');
+  testPages('/subdir/_layout.tsx', '/subdir', 'layout');
+  testPages('/subdir/[page].tsx', '/subdir/:page', 'page');
+  testPages('/[user]/posts.tsx', '/:user/posts', 'page');
+  testPages('/[user]/_layout.tsx', '/:user', 'layout');
+  testPages('/subdir/[page]/[other].tsx', '/subdir/:page/:other', 'page');
+  testPages('/[page]/[other]/index.js', '/:page/:other', 'page');
+  testPages('/[...data].js', '/:*data', 'page');
+  testPages('/[[...data]].js', '/:*?data', 'page');
+  testPages('/[...data]/index.tsx', '/:*data', 'page');
+  testPages('/[[...data]]/index.jsx', '/:*?data', 'page');
+  testPages('/hello/[...data]/index.tsx', '/hello/:*data', 'page');
+  testPages('/hello/[[...data]]/index.jsx', '/hello/:*?data', 'page');
+  testPages('/[...data]/_layout.tsx', '/:*data', 'layout');
+  testPages('/[[...data]]/_layout.jsx', '/:*?data', 'layout');
+  testPages('/hello/[...data]/_layout.tsx', '/hello/:*data', 'layout');
+  testPages('/hello/[[...data]]/_layout.jsx', '/hello/:*?data', 'layout');
+  // Parenthesis is the error location (column:length)
+  testPages.fails('/subdir/[', 'Missing "]" to match this route parameter (8:1)');
+  testPages.fails('/subdir/[a', 'Missing "]" to match this route parameter (8:2)');
+  testPages.fails('/subdir/[page.tsx', 'Missing "]" to match this route parameter (8:9)');
+  testPages.fails('/subdir/[]/hello', 'Parameter needs a name (8:2)');
+  testPages.fails('/subdir/[.hello]-hello.tsx', 'Parameter name cannot start with \".\" (use \"...\" for catch-all) (8:8)');
+  testPages.fails('/subdir/[..hello]-hello.tsx', 'Parameter name cannot start with \".\" (use \"...\" for catch-all) (8:9)');
+  testPages.fails('/subdir/[...hello]-hello.tsx', 'Parameters must take up the entire file name (8:10)');
+  testPages.fails('/subdir/[...hello]/bar.tsx', 'Catch-all parameter must be at the end of a route (8:10)');
+  testPages.fails('/hello/[[optional_param]]/_layout.tsx', 'Optional parameters can only be catch-all (change to "[[...optional_param]]" or remove extra brackets) (7:18)');
+
+  const testApp = testRoutePattern('nextjs-app-ui');
+  testApp('/page.tsx', '', 'page');
+  testApp('/layout.tsx', '', 'layout');
+  testApp('/route/[param]/page.tsx', '/route/:param', 'page');
+  testApp('/route/(group)/page.tsx', '/route/(group)', 'page');
+  testApp('/route/[param]/not-found.tsx', '/route/:param', 'extra');
+});
\ No newline at end of file
diff --git a/test/bun.lockb b/test/bun.lockb
index b025efa7b6e562..13caab649147e2 100755
Binary files a/test/bun.lockb and b/test/bun.lockb differ
diff --git a/test/bundler/bundler_bun.test.ts b/test/bundler/bundler_bun.test.ts
index 63820dd4c3b8de..43b29c517e9725 100644
--- a/test/bundler/bundler_bun.test.ts
+++ b/test/bundler/bundler_bun.test.ts
@@ -93,4 +93,13 @@ error: Hello World`,
       },
     },
   });
+  itBundled("bun/unicode comment", {
+    target: "bun",
+    files: {
+      "/a.ts": /* js */ `
+        /* æ */
+      `,
+    },
+    run: { stdout: "" },
+  });
 });
diff --git a/test/bundler/bundler_loader.test.ts b/test/bundler/bundler_loader.test.ts
index c6f1e3ce3ca099..3611d9c3b93265 100644
--- a/test/bundler/bundler_loader.test.ts
+++ b/test/bundler/bundler_loader.test.ts
@@ -1,6 +1,6 @@
-import { fileURLToPath } from "bun";
-import { describe } from "bun:test";
-import fs from "node:fs";
+import { fileURLToPath, Loader } from "bun";
+import { describe, expect } from "bun:test";
+import fs, { readdirSync } from "node:fs";
 import { join } from "path";
 import { itBundled } from "./expectBundled";
 
@@ -56,6 +56,7 @@ describe("bundler", async () => {
       });
     });
   }
+
   itBundled("bun/loader-text-file", {
     target: "bun",
     outfile: "",
@@ -114,4 +115,65 @@ describe("bundler", async () => {
       stdout: moon,
     },
   });
+
+  const loaders: Loader[] = ["wasm", "css", "json", "file" /* "napi" */, "text"];
+  const exts = ["wasm", "css", "json", ".lmao" /*  ".node" */, ".txt"];
+  for (let i = 0; i < loaders.length; i++) {
+    const loader = loaders[i];
+    const ext = exts[i];
+    itBundled(`bun/loader-copy-file-entry-point-with-onLoad-${loader}`, {
+      target: "bun",
+      outdir: "/out",
+      experimentalCss: false,
+      files: {
+        [`/entry.${ext}`]: /* js */ `{ "hello": "friends" }`,
+      },
+      entryNaming: "[dir]/[name]-[hash].[ext]",
+      plugins(builder) {
+        builder.onLoad({ filter: new RegExp(`.${loader}$`) }, async ({ path }) => {
+          const result = await Bun.file(path).text();
+          return { contents: result, loader };
+        });
+      },
+      onAfterBundle(api) {
+        const jsFile = readdirSync(api.outdir).find(x => x.endsWith(".js"))!;
+        const module = require(join(api.outdir, jsFile));
+
+        if (loader === "json") {
+          expect(module.default).toStrictEqual({ hello: "friends" });
+        } else if (loader === "text") {
+          expect(module.default).toStrictEqual('{ "hello": "friends" }');
+        } else {
+          api.assertFileExists(join("out", module.default));
+        }
+      },
+    });
+  }
+
+  for (let i = 0; i < loaders.length; i++) {
+    const loader = loaders[i];
+    const ext = exts[i];
+    itBundled(`bun/loader-copy-file-entry-point-${loader}`, {
+      target: "bun",
+      outfile: "",
+      outdir: "/out",
+      experimentalCss: false,
+      files: {
+        [`/entry.${ext}`]: /* js */ `{ "hello": "friends" }`,
+      },
+      entryNaming: "[dir]/[name]-[hash].[ext]",
+      onAfterBundle(api) {
+        const jsFile = readdirSync(api.outdir).find(x => x.endsWith(".js"))!;
+        const module = require(join(api.outdir, jsFile));
+
+        if (loader === "json") {
+          expect(module.default).toStrictEqual({ hello: "friends" });
+        } else if (loader === "text") {
+          expect(module.default).toStrictEqual('{ "hello": "friends" }');
+        } else {
+          api.assertFileExists(join("out", module.default));
+        }
+      },
+    });
+  }
 });
diff --git a/test/bundler/bundler_minify.test.ts b/test/bundler/bundler_minify.test.ts
index 9919ed6cf76839..8d07f3727c1f3f 100644
--- a/test/bundler/bundler_minify.test.ts
+++ b/test/bundler/bundler_minify.test.ts
@@ -3,9 +3,6 @@ import { itBundled } from "./expectBundled";
 
 describe("bundler", () => {
   itBundled("minify/TemplateStringFolding", {
-    // TODO: https://github.com/oven-sh/bun/issues/4217
-    todo: true,
-
     files: {
       "/entry.js": /* js */ `
         capture(\`\${1}-\${2}-\${3}-\${null}-\${undefined}-\${true}-\${false}\`);
@@ -28,6 +25,11 @@ describe("bundler", () => {
         capture(\`😋📋👌\`.length == 6)
         capture(\`😋📋👌\`.length === 2)
         capture(\`😋📋👌\`.length == 2)
+        capture(\`\\n\`.length)
+        capture(\`\n\`.length)
+        capture("\\uD800\\uDF34".length)
+        capture("\\u{10334}".length)
+        capture("𐌴".length)
       `,
     },
     capture: [
@@ -51,6 +53,11 @@ describe("bundler", () => {
       "!0",
       "!1",
       "!1",
+      "1",
+      "1",
+      "2",
+      "2",
+      "2",
     ],
     minifySyntax: true,
     target: "bun",
@@ -475,9 +482,11 @@ describe("bundler", () => {
         capture(+'-123.567');
         capture(+'8.325');
         capture(+'100000000');
-        // unsupported
         capture(+'\\u0030\\u002e\\u0031');
         capture(+'\\x30\\x2e\\x31');
+        capture(+'NotANumber');
+        // not supported
+        capture(+'æ');
       `,
     },
     minifySyntax: true,
@@ -486,9 +495,11 @@ describe("bundler", () => {
       "-123.567",
       "8.325",
       "1e8",
+      "0.1",
+      "0.1",
+      "NaN",
       // untouched
-      "+\"0.1\"",
-      "+\"0.1\"",
+      '+"æ"',
     ],
   });
 });
diff --git a/test/bundler/bundler_npm.test.ts b/test/bundler/bundler_npm.test.ts
index 73d4b1556ef709..58eb0aa8f27d12 100644
--- a/test/bundler/bundler_npm.test.ts
+++ b/test/bundler/bundler_npm.test.ts
@@ -58,16 +58,16 @@ describe("bundler", () => {
         ],
         mappings: [
           ["react.development.js:524:'getContextName'", "1:5426:Y1"],
-          ["react.development.js:2495:'actScopeDepth'", "1:26051:GJ++"],
+          ["react.development.js:2495:'actScopeDepth'", "23:4092:GJ++"],
           ["react.development.js:696:''Component'", '1:7488:\'Component "%s"'],
-          ["entry.tsx:6:'\"Content-Type\"'", '1:221651:"Content-Type"'],
-          ["entry.tsx:11:'<html>'", "1:221905:void"],
-          ["entry.tsx:23:'await'", "1:222005:await"],
+          ["entry.tsx:6:'\"Content-Type\"'", '100:18849:"Content-Type"'],
+          ["entry.tsx:11:'<html>'", "100:19103:void"],
+          ["entry.tsx:23:'await'", "100:19203:await"],
         ],
       },
     },
     expectExactFilesize: {
-      "out/entry.js": 222273,
+      "out/entry.js": 222164,
     },
     run: {
       stdout: "<!DOCTYPE html><html><body><h1>Hello World</h1><p>This is an example.</p></body></html>",
diff --git a/test/bundler/bundler_string.test.ts b/test/bundler/bundler_string.test.ts
index 2b5901d7826863..88efba7780bc53 100644
--- a/test/bundler/bundler_string.test.ts
+++ b/test/bundler/bundler_string.test.ts
@@ -11,7 +11,7 @@ interface TemplateStringTest {
 const templateStringTests: Record<string, TemplateStringTest> = {
   // note for writing tests: .print is .trim()'ed due to how run.stdout works
   Empty: { expr: '""', captureRaw: '""' },
-  NullByte: { expr: '"hello\0"', captureRaw: '"hello\0"' },
+  NullByte: { expr: '"hello\0"', captureRaw: '"hello\\x00"' },
   EmptyTemplate: { expr: "``", captureRaw: '""' },
   ConstantTemplate: { expr: "`asdf`", captureRaw: '"asdf"' },
   AddConstant: { expr: "`${7 + 6}`", capture: true },
@@ -61,15 +61,15 @@ const templateStringTests: Record<string, TemplateStringTest> = {
   },
   TernaryWithEscapeVariable: {
     expr: '`${"1"}\\${${VARIABLE ? "SOMETHING" : ""}`',
-    captureRaw: '`${"1"}\\${${VARIABLE?"SOMETHING":""}`',
+    captureRaw: '`1\\${${VARIABLE?"SOMETHING":""}`',
   },
   TernaryWithEscapeTrue: {
     expr: '`${"1"}\\${${true ? "SOMETHING" : ""}`',
-    captureRaw: '`${"1"}\\${${"SOMETHING"}`',
+    captureRaw: '"1${SOMETHING"',
   },
   TernaryWithEscapeFalse: {
     expr: '`${"1"}\\${${false ? "SOMETHING" : ""}`',
-    captureRaw: '`${"1"}\\${${""}`',
+    captureRaw: '"1${"',
   },
   Fold: { expr: "`a${'b'}c${'d'}e`", capture: true },
   FoldNested1: { expr: "`a${`b`}c${`${'d'}`}e`", capture: true },
diff --git a/test/bundler/cli.test.ts b/test/bundler/cli.test.ts
index 4830840f388dad..070c6cea986a77 100644
--- a/test/bundler/cli.test.ts
+++ b/test/bundler/cli.test.ts
@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import { bunEnv, bunExe, tmpdirSync } from "harness";
-import fs from "node:fs";
-import path from "node:path";
+import fs, { mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import path, { join } from "node:path";
+import { isWindows } from "harness";
 
 describe("bun build", () => {
   test("warnings dont return exit code 1", () => {
@@ -78,4 +79,95 @@ describe("bun build", () => {
     expect(stdout.toString()).toContain(path.join(baseDir, "我") + "\n");
     expect(stdout.toString()).toContain(path.join(baseDir, "我", "我.ts") + "\n");
   });
+
+  test.skipIf(!isWindows)("should be able to handle pretty path when using pnpm +  #14685", async () => {
+    // this test code follows the same structure as and
+    // is based on the code for testing issue 4893
+
+    let testDir = tmpdirSync();
+
+    // Clean up from prior runs if necessary
+    rmSync(testDir, { recursive: true, force: true });
+
+    // Create a directory with our test file
+    mkdirSync(testDir, { recursive: true });
+
+    writeFileSync(
+      join(testDir, "index.ts"),
+      "import chalk from \"chalk\"; export function main() { console.log(chalk.red('Hello, World!')); }",
+    );
+    writeFileSync(
+      join(testDir, "package.json"),
+      `
+  {
+  "dependencies": {
+    "chalk": "^5.3.0"
+  }
+}`,
+    );
+    testDir = realpathSync(testDir);
+
+    Bun.spawnSync({
+      cmd: [bunExe(), "x", "pnpm@9", "i"],
+      env: bunEnv,
+      stderr: "pipe",
+      cwd: testDir,
+    });
+    // bun build --entrypoints ./index.ts --outdir ./dist --target node
+    const { stderr, exitCode } = Bun.spawnSync({
+      cmd: [
+        bunExe(),
+        "build",
+        "--entrypoints",
+        join(testDir, "index.ts"),
+        "--outdir",
+        join(testDir, "dist"),
+        "--target",
+        "node",
+      ],
+      env: bunEnv,
+      stderr: "pipe",
+      stdout: "pipe",
+    });
+    expect(stderr.toString()).toBe("");
+    expect(exitCode).toBe(0);
+  });
+}, 10_000);
+
+test.skipIf(!isWindows)("should be able to handle pretty path on windows #13897", async () => {
+  // this test code follows the same structure as and
+  // is based on the code for testing issue 4893
+
+  let testDir = tmpdirSync();
+
+  // Clean up from prior runs if necessary
+  rmSync(testDir, { recursive: true, force: true });
+
+  // Create a directory with our test file
+  mkdirSync(testDir, { recursive: true });
+
+  writeFileSync(
+    join(testDir, "index.ts"),
+    "import chalk from \"chalk\"; export function main() { console.log(chalk.red('Hello, World!')); }",
+  );
+
+  writeFileSync(join(testDir, "chalk.ts"), "function red(value){ consol.error(value); } export default { red };");
+  testDir = realpathSync(testDir);
+
+  // bun build --entrypoints ./index.ts --outdir ./dist --target node
+  const buildOut = await Bun.build({
+    entrypoints: [join(testDir, "index.ts")],
+    outdir: join(testDir, "dist"),
+    minify: true,
+    sourcemap: "linked",
+    plugins: [
+      {
+        name: "My windows plugin",
+        async setup(build) {
+          build.onResolve({ filter: /chalk/ }, () => ({ path: join(testDir, "chalk.ts").replaceAll("/", "\\") }));
+        },
+      },
+    ],
+  });
+  expect(buildOut?.success).toBe(true);
 });
diff --git a/test/bundler/expectBundled.ts b/test/bundler/expectBundled.ts
index 50607cf44f0599..12671fc9b839e4 100644
--- a/test/bundler/expectBundled.ts
+++ b/test/bundler/expectBundled.ts
@@ -167,6 +167,7 @@ export interface BundlerTestInput {
   format?: "esm" | "cjs" | "iife" | "internal_bake_dev";
   globalName?: string;
   ignoreDCEAnnotations?: boolean;
+  bytecode?: boolean;
   emitDCEAnnotations?: boolean;
   inject?: string[];
   jsx?: {
@@ -574,7 +575,9 @@ function expectBundled(
     const entryPaths = entryPoints.map(file => path.join(root, file));
 
     if (external) {
-      external = external.map(x => (typeof x !== "string" ? x : x.replace(/\{\{root\}\}/g, root)));
+      external = external.map(x =>
+        typeof x !== "string" ? x : x.replaceAll("{{root}}", root.replaceAll("\\", "\\\\")),
+      );
     }
 
     if (generateOutput === false) outputPaths = [];
@@ -625,7 +628,9 @@ function expectBundled(
       const filename = path.join(root, file);
       mkdirSync(path.dirname(filename), { recursive: true });
       const formattedContents =
-        typeof contents === "string" ? dedent(contents).replace(/\{\{root\}\}/g, root) : contents;
+        typeof contents === "string"
+          ? dedent(contents).replaceAll("{{root}}", root.replaceAll("\\", "\\\\"))
+          : contents;
       writeFileSync(filename, formattedContents);
     }
 
@@ -1350,7 +1355,9 @@ for (const [key, blob] of build.outputs) {
     for (const [file, contents] of Object.entries(runtimeFiles ?? {})) {
       mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
       const formattedContents =
-        typeof contents === "string" ? dedent(contents).replace(/\{\{root\}\}/g, root) : contents;
+        typeof contents === "string"
+          ? dedent(contents).replaceAll("{{root}}", root.replaceAll("\\", "\\\\"))
+          : contents;
       writeFileSync(path.join(root, file), formattedContents);
     }
 
diff --git a/test/bundler/transpiler/transpiler.test.js b/test/bundler/transpiler/transpiler.test.js
index 2763f2b2af9ed6..7bb5bb1987c6a4 100644
--- a/test/bundler/transpiler/transpiler.test.js
+++ b/test/bundler/transpiler/transpiler.test.js
@@ -1668,8 +1668,33 @@ console.log(<div {...obj} key="after" />);`),
       expectPrinted_(`import("./foo.json", { type: "json" });`, `import("./foo.json")`);
     });
 
-    it("import with unicode escape", () => {
-      expectPrinted_(`import { name } from 'mod\\u1011';`, `import { name } from "mod\\u1011"`);
+    it("import with unicode", () => {
+      expectPrinted_(`import { name } from 'modထ';`, `import { name } from "modထ"`);
+      expectPrinted_(`import { name } from 'mod\\u1011';`, `import { name } from "modထ"`);
+      expectPrinted_(`import('modထ');`, `import("modထ")`);
+      expectPrinted_(`import('mod\\u1011');`, `import("modထ")`);
+    });
+    it("import with quote", () => {
+      expectPrinted_(`import { name } from '".ts';`, `import { name } from '".ts'`);
+    });
+
+    it("string quote selection", () => {
+      expectPrinted_(`console.log("\\n")`, "console.log(`\n`)");
+      expectPrinted_(`console.log("\\"")`, `console.log('"')`);
+      expectPrinted_(`console.log('\\'')`, `console.log("'")`);
+      expectPrinted_("console.log(`\\`hi\\``)", "console.log(`\\`hi\\``)");
+      expectPrinted_(`console.log("ထ")`, `console.log("ထ")`);
+      expectPrinted_(`console.log("\\u1011")`, `console.log("ထ")`);
+    });
+
+    it("unicode surrogates", () => {
+      expectPrinted_(`console.log("𐌴")`, 'console.log("\\uD800\\uDF34")');
+      expectPrinted_(`console.log("\\u{10334}")`, 'console.log("\\uD800\\uDF34")');
+      expectPrinted_(`console.log("\\uD800\\uDF34")`, 'console.log("\\uD800\\uDF34")');
+      expectPrinted_(`console.log("\\u{10334}" === "\\uD800\\uDF34")`, "console.log(true)");
+      expectPrinted_(`console.log("\\u{10334}" === "\\uDF34\\uD800")`, "console.log(false)");
+      expectPrintedMin_(`console.log("abc" + "def")`, 'console.log("abcdef")');
+      expectPrintedMin_(`console.log("\\uD800" + "\\uDF34")`, 'console.log("\\uD800" + "\\uDF34")');
     });
 
     it("fold string addition", () => {
@@ -1810,7 +1835,7 @@ export const { dead } = { dead: "hello world!" };
       expect(bunTranspiler.transformSync(input, object).trim()).toBe(output);
     });
 
-    it.skip("rewrite string to length", () => {
+    it("rewrite string to length", () => {
       expectBunPrinted_(`export const foo = "a".length + "b".length;`, `export const foo = 2`);
       // check rope string
       expectBunPrinted_(`export const foo = ("a" + "b").length;`, `export const foo = 2`);
@@ -1819,6 +1844,8 @@ export const { dead } = { dead: "hello world!" };
         `export const foo = "😋 Get Emoji — All Emojis to ✂️ Copy and 📋 Paste 👌".length;`,
         `export const foo = 52`,
       );
+      // no rope string for non-ascii
+      expectBunPrinted_(`export const foo = ("æ" + "™").length;`, `export const foo = ("æ" + "™").length`);
     });
 
     describe("Bun.js", () => {
diff --git a/test/cli/hot/hot.test.ts b/test/cli/hot/hot.test.ts
index b819cdff2f0356..9b53bb733c3420 100644
--- a/test/cli/hot/hot.test.ts
+++ b/test/cli/hot/hot.test.ts
@@ -17,6 +17,21 @@ beforeEach(() => {
   cwd = hotPath;
 });
 
+it("preload not found should exit with code 1 and not time out", async () => {
+  const root = hotRunnerRoot;
+  const runner = spawn({
+    cmd: [bunExe(), "--preload=/dev/foobarbarbar", "--hot", root],
+    env: bunEnv,
+    stdout: "inherit",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  await runner.exited;
+  expect(runner.signalCode).toBe(null);
+  expect(runner.exitCode).toBe(1);
+  expect(await new Response(runner.stderr).text()).toContain("preload not found");
+});
+
 it(
   "should hot reload when file is overwritten",
   async () => {
diff --git a/test/cli/install/bun-add.test.ts b/test/cli/install/bun-add.test.ts
index cfa66430018b47..f670bc68278f51 100644
--- a/test/cli/install/bun-add.test.ts
+++ b/test/cli/install/bun-add.test.ts
@@ -2,7 +2,7 @@ import { file, spawn } from "bun";
 import { afterAll, afterEach, beforeAll, beforeEach, expect, it, setDefaultTimeout } from "bun:test";
 import { access, appendFile, copyFile, mkdir, readlink, rm, writeFile } from "fs/promises";
 import { bunExe, bunEnv as env, tmpdirSync, toBeValidBin, toBeWorkspaceLink, toHaveBins } from "harness";
-import { join, relative } from "path";
+import { join, relative, resolve } from "path";
 import {
   check_npm_auth_type,
   dummyAfterAll,
@@ -927,9 +927,9 @@ it("should add aliased dependency (GitHub)", async () => {
   expect(await readdirSorted(join(package_dir, "node_modules", ".cache", "uglify"))).toEqual([
     "mishoo-UglifyJS-e219a9a@@@1",
   ]);
-  expect(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))).toBe(
-    join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"),
-  );
+  expect(
+    resolve(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))),
+  ).toBe(join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"));
   expect(await readdirSorted(join(package_dir, "node_modules", "uglify"))).toEqual([
     ".bun-tag",
     ".gitattributes",
diff --git a/test/cli/install/bun-install.test.ts b/test/cli/install/bun-install.test.ts
index b961d1afd7f32f..9bdb9c4d6131ee 100644
--- a/test/cli/install/bun-install.test.ts
+++ b/test/cli/install/bun-install.test.ts
@@ -23,7 +23,7 @@ import {
   runBunInstall,
   isWindows,
 } from "harness";
-import { join, sep } from "path";
+import { join, sep, resolve } from "path";
 import {
   dummyAfterAll,
   dummyAfterEach,
@@ -3452,9 +3452,9 @@ it("should handle GitHub URL in dependencies (user/repo#commit-id)", async () =>
   expect(await readdirSorted(join(package_dir, "node_modules", ".cache", "uglify"))).toEqual([
     "mishoo-UglifyJS-e219a9a@@@1",
   ]);
-  expect(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))).toBe(
-    join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"),
-  );
+  expect(
+    resolve(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))),
+  ).toBe(join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"));
   expect(await readdirSorted(join(package_dir, "node_modules", "uglify"))).toEqual([
     ".bun-tag",
     ".gitattributes",
@@ -3518,9 +3518,9 @@ it("should handle GitHub URL in dependencies (user/repo#tag)", async () => {
   expect(await readdirSorted(join(package_dir, "node_modules", ".cache", "uglify"))).toEqual([
     "mishoo-UglifyJS-e219a9a@@@1",
   ]);
-  expect(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))).toBe(
-    join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"),
-  );
+  expect(
+    resolve(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))),
+  ).toBe(join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"));
   expect(await readdirSorted(join(package_dir, "node_modules", "uglify"))).toEqual([
     ".bun-tag",
     ".gitattributes",
@@ -3744,9 +3744,9 @@ it("should handle GitHub URL in dependencies (github:user/repo#tag)", async () =
   expect(await readdirSorted(join(package_dir, "node_modules", ".cache", "uglify"))).toEqual([
     "mishoo-UglifyJS-e219a9a@@@1",
   ]);
-  expect(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))).toBe(
-    join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"),
-  );
+  expect(
+    resolve(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))),
+  ).toBe(join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"));
   expect(await readdirSorted(join(package_dir, "node_modules", "uglify"))).toEqual([
     ".bun-tag",
     ".gitattributes",
@@ -3868,9 +3868,9 @@ it("should handle GitHub URL in dependencies (git://github.com/user/repo.git#com
   expect(await readdirSorted(join(package_dir, "node_modules", ".cache", "uglify"))).toEqual([
     "mishoo-UglifyJS-e219a9a@@@1",
   ]);
-  expect(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))).toBe(
-    join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"),
-  );
+  expect(
+    resolve(await readlink(join(package_dir, "node_modules", ".cache", "uglify", "mishoo-UglifyJS-e219a9a@@@1"))),
+  ).toBe(join(package_dir, "node_modules", ".cache", "@GH@mishoo-UglifyJS-e219a9a@@@1"));
   expect(await readdirSorted(join(package_dir, "node_modules", "uglify"))).toEqual([
     ".bun-tag",
     ".gitattributes",
diff --git a/test/cli/install/bun-run.test.ts b/test/cli/install/bun-run.test.ts
index 717836b687299c..ab3ca924289e30 100644
--- a/test/cli/install/bun-run.test.ts
+++ b/test/cli/install/bun-run.test.ts
@@ -521,3 +521,23 @@ it("should pass arguments correctly in scripts", async () => {
     expect(exitCode).toBe(0);
   }
 });
+
+it("should run with bun instead of npm even with leading spaces", async () => {
+  const dir = tempDirWithFiles("test", {
+    "package.json": JSON.stringify({
+      workspaces: ["a", "b"],
+      scripts: { "root_script": "   npm run other_script    ", "other_script": "   echo hi    " },
+    }),
+  });
+  {
+    const { stdout, stderr, exitCode } = spawnSync({
+      cmd: [bunExe(), "run", "root_script"],
+      cwd: dir,
+      env: bunEnv,
+    });
+
+    expect(stderr.toString()).toBe("$    bun run other_script    \n$    echo hi    \n");
+    expect(stdout.toString()).toEndWith("hi\n");
+    expect(exitCode).toBe(0);
+  }
+});
diff --git a/test/cli/install/registry/__snapshots__/bun-install-registry.test.ts.snap b/test/cli/install/registry/__snapshots__/bun-install-registry.test.ts.snap
index 0f33e6cd4f800d..f21ad002a6c578 100644
--- a/test/cli/install/registry/__snapshots__/bun-install-registry.test.ts.snap
+++ b/test/cli/install/registry/__snapshots__/bun-install-registry.test.ts.snap
@@ -126,3 +126,11 @@ exports[`outdated NO_COLOR works 1`] = `
 |--------------------------------------|
 "
 `;
+
+exports[`auto-install symlinks (and junctions) are created correctly in the install cache 1`] = `
+"{
+  name: "is-number",
+  version: "2.0.0",
+}
+"
+`;
diff --git a/test/cli/install/registry/bun-install-registry.test.ts b/test/cli/install/registry/bun-install-registry.test.ts
index ddfda84185e67f..574859251d48d2 100644
--- a/test/cli/install/registry/bun-install-registry.test.ts
+++ b/test/cli/install/registry/bun-install-registry.test.ts
@@ -520,6 +520,31 @@ ${Object.keys(opts)
   );
 });
 
+describe("auto-install", () => {
+  test("symlinks (and junctions) are created correctly in the install cache", async () => {
+    const { stdout, stderr, exited } = spawn({
+      cmd: [bunExe(), "--print", "require('is-number')"],
+      cwd: packageDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...env,
+        BUN_INSTALL_CACHE_DIR: join(packageDir, ".bun-cache"),
+      },
+    });
+
+    const out = await Bun.readableStreamToText(stdout);
+    expect(out).toMatchSnapshot();
+    const err = await Bun.readableStreamToText(stderr);
+    expect(err).not.toContain("error:");
+    expect(await exited).toBe(0);
+
+    expect(resolve(await readlink(join(packageDir, ".bun-cache", "is-number", "2.0.0@@localhost@@@1")))).toBe(
+      join(packageDir, ".bun-cache", "is-number@2.0.0@@localhost@@@1"),
+    );
+  });
+});
+
 describe("certificate authority", () => {
   const mockRegistryFetch = function (opts?: any): (req: Request) => Promise<Response> {
     return async function (req: Request) {
diff --git a/test/harness.ts b/test/harness.ts
index 652d99b1f91324..82d3231b6fc914 100644
--- a/test/harness.ts
+++ b/test/harness.ts
@@ -5,6 +5,7 @@ import { readFile, readlink, writeFile } from "fs/promises";
 import fs, { closeSync, openSync } from "node:fs";
 import os from "node:os";
 import { dirname, isAbsolute, join } from "path";
+import detect_libc from "detect-libc";
 
 type Awaitable<T> = T | Promise<T>;
 
@@ -18,6 +19,7 @@ export const isIntelMacOS = isMacOS && process.arch === "x64";
 export const isDebug = Bun.version.includes("debug");
 export const isCI = process.env.CI !== undefined;
 export const isBuildKite = process.env.BUILDKITE === "true";
+export const libc_family = detect_libc.familySync();
 
 // Use these to mark a test as flaky or broken.
 // This will help us keep track of these tests.
@@ -1365,3 +1367,19 @@ export function waitForFileToExist(path: string, interval: number) {
     sleepSync(interval);
   }
 }
+
+export function libcPathForDlopen() {
+  switch (process.platform) {
+    case "linux":
+      switch (libc_family) {
+        case "glibc":
+          return "libc.so.6";
+        case "musl":
+          return "/usr/lib/libc.so";
+      }
+    case "darwin":
+      return "libc.dylib";
+    default:
+      throw new Error("TODO");
+  }
+}
diff --git a/test/js/bun/http/bun-server.test.ts b/test/js/bun/http/bun-server.test.ts
index 8cc8eb20ff71e7..de430f36e39b1c 100644
--- a/test/js/bun/http/bun-server.test.ts
+++ b/test/js/bun/http/bun-server.test.ts
@@ -316,6 +316,27 @@ describe("Server", () => {
       expect(response.url).toBe(url);
     }
   });
+
+
+  test('server should return a body for a OPTIONS Request', async () => {
+    using server = Bun.serve({
+      port: 0,
+      fetch(req) {
+        return new Response("Hello World!");
+      },
+    });
+    {
+      const url = `http://${server.hostname}:${server.port}/`;
+      const response = await fetch(new Request(url, {
+        method: 'OPTIONS',
+      }));
+      expect(await response.text()).toBe("Hello World!");
+      expect(response.status).toBe(200);
+      expect(response.url).toBe(url);
+    }
+  });
+
+
   test("abort signal on server with stream", async () => {
     {
       let signalOnServer = false;
@@ -435,7 +456,7 @@ describe("Server", () => {
       env: bunEnv,
       stderr: "pipe",
     });
-    expect(stderr).toBeEmpty();
+    expect(stderr.toString('utf-8')).toBeEmpty();
     expect(exitCode).toBe(0);
   });
 });
diff --git a/test/js/bun/ini/ini.test.ts b/test/js/bun/ini/ini.test.ts
index 32da995aba743d..14667b673ff1da 100644
--- a/test/js/bun/ini/ini.test.ts
+++ b/test/js/bun/ini/ini.test.ts
@@ -48,6 +48,13 @@ wow = 'hi'
       expected: { hi: "\\production" },
     });
 
+    envVarTest({
+      name: "backslashes",
+      ini: "filepath=C:\\Home\\someuser\\My Documents\nfilepath2=\\\\\\\\TwoBackslashes",
+      env: {},
+      expected: { filepath: "C:\\Home\\someuser\\My Documents", filepath2: "\\\\TwoBackslashes" },
+    });
+
     envVarTest({
       name: "basic",
       ini: /* ini */ `
diff --git a/test/js/bun/spawn/bun-ipc-inherit.test.ts b/test/js/bun/spawn/bun-ipc-inherit.test.ts
index 1c62c53de9a4e3..00a4ca8988c09c 100644
--- a/test/js/bun/spawn/bun-ipc-inherit.test.ts
+++ b/test/js/bun/spawn/bun-ipc-inherit.test.ts
@@ -1,12 +1,13 @@
 import { spawn } from "bun";
 import { expect, it } from "bun:test";
-import { bunExe, isWindows } from "harness";
+import { bunExe, isWindows, tmpdirSync } from "harness";
 import fs from "node:fs/promises";
 import path from "path";
 
 it.todoIf(isWindows)("spawning a bun package script should inherit the ipc fd", async () => {
+  const x = tmpdirSync();
   await fs.writeFile(
-    path.join(process.cwd(), "package.json"),
+    path.join(x, "package.json"),
     JSON.stringify({
       scripts: {
         test: `${bunExe()} -e 'process.send("hello")'`,
@@ -21,6 +22,7 @@ it.todoIf(isWindows)("spawning a bun package script should inherit the ipc fd",
       testMessage = message;
     },
     stdio: ["inherit", "inherit", "inherit"],
+    cwd: x,
   });
 
   await child.exited;
diff --git a/test/js/bun/spawn/does-not-hang.js b/test/js/bun/spawn/does-not-hang.js
index 32221f56d86787..3a06a045b6de65 100644
--- a/test/js/bun/spawn/does-not-hang.js
+++ b/test/js/bun/spawn/does-not-hang.js
@@ -1,7 +1,7 @@
 import { shellExe } from "harness";
 
 const s = Bun.spawn({
-  cmd: [shellExe(), "-c", "sleep", "999999"],
+  cmd: [shellExe(), "-c", "sleep 999999"],
 });
 
 s.unref();
diff --git a/test/js/bun/spawn/spawn.test.ts b/test/js/bun/spawn/spawn.test.ts
index 345e458e22f669..4f2adf20356932 100644
--- a/test/js/bun/spawn/spawn.test.ts
+++ b/test/js/bun/spawn/spawn.test.ts
@@ -152,7 +152,7 @@ for (let [gcTick, label] of [
 
       it("nothing to stdout and sleeping doesn't keep process open 4ever", async () => {
         const proc = spawn({
-          cmd: [shellExe(), "-c", "sleep", "0.1"],
+          cmd: [shellExe(), "-c", "sleep 0.1"],
         });
         gcTick();
         for await (const _ of proc.stdout) {
@@ -366,7 +366,7 @@ for (let [gcTick, label] of [
 
       it("kill(SIGKILL) works", async () => {
         const process = spawn({
-          cmd: [shellExe(), "-c", "sleep", "1000"],
+          cmd: [shellExe(), "-c", "sleep 1000"],
           stdout: "pipe",
         });
         gcTick();
@@ -377,7 +377,7 @@ for (let [gcTick, label] of [
 
       it("kill() works", async () => {
         const process = spawn({
-          cmd: [shellExe(), "-c", "sleep", "1000"],
+          cmd: [shellExe(), "-c", "sleep 1000"],
           stdout: "pipe",
         });
         gcTick();
@@ -551,7 +551,7 @@ if (!process.env.BUN_FEATURE_FLAG_FORCE_WAITER_THREAD && isPosix && !isMacOS) {
 }
 
 describe("spawn unref and kill should not hang", () => {
-  const cmd = [shellExe(), "-c", "sleep", "0.001"];
+  const cmd = [shellExe(), "-c", "sleep 0.001"];
 
   it("kill and await exited", async () => {
     const promises = new Array(10);
@@ -635,7 +635,7 @@ async function runTest(sleep: string, order = ["sleep", "kill", "unref", "exited
   console.log("running", order.join(","), "x 100");
   for (let i = 0; i < (isWindows ? 10 : 100); i++) {
     const proc = spawn({
-      cmd: [shellExe(), "-c", "sleep", sleep],
+      cmd: [shellExe(), "-c", `sleep ${sleep}`],
       stdout: "ignore",
       stderr: "ignore",
       stdin: "ignore",
diff --git a/test/js/bun/test/expect.test.js b/test/js/bun/test/expect.test.js
index 55b48abceee061..4f5b339ffb83cd 100644
--- a/test/js/bun/test/expect.test.js
+++ b/test/js/bun/test/expect.test.js
@@ -233,6 +233,31 @@ describe("expect()", () => {
     expect([, 1]).toEqual([undefined, 1]);
   });
 
+  describe("toEqual() with DOM types", () => {
+    test("URLSearchParams", () => {
+      expect(new URLSearchParams("a=1")).not.toEqual(new URLSearchParams("b=1"));
+      expect(new URLSearchParams("a=1")).toEqual(new URLSearchParams("a=1"));
+      expect(new URLSearchParams("a=1&b=2")).not.toEqual(new URLSearchParams("a=1&"));
+    });
+
+    if (isBun) {
+      test("URL", () => {
+        expect(new URL("https://example.com")).toEqual(new URL("https://example.com"));
+        expect(new URL("http://wat")).not.toStrictEqual(new URL("http://huh"));
+      });
+    }
+
+    test("Headers", () => {
+      expect(new Headers({ "a": "1" })).toEqual(new Headers({ "a": "1" }));
+      expect(new Headers({ "a": "1" })).not.toEqual(new Headers({ "b": "1" }));
+      expect(new Headers({ "a": "1" })).not.toEqual(new Headers({ "a": "2" }));
+      expect(new Headers({ "a": "1" })).not.toEqual(new Headers({ "a": "1", "b": "2" }));
+    });
+
+    // TODO: FormData
+    // It would need to compare Blob, which is tricky.
+  });
+
   describe("BigInt", () => {
     it("compares correctly (literal)", () => {
       expect(42n).toBe(42n);
diff --git a/test/js/junit-reporter/junit.test.js b/test/js/junit-reporter/junit.test.js
new file mode 100644
index 00000000000000..fdbc19196ba94c
--- /dev/null
+++ b/test/js/junit-reporter/junit.test.js
@@ -0,0 +1,234 @@
+import { it, describe, expect } from "bun:test";
+import { file, spawn } from "bun";
+import { tempDirWithFiles, bunEnv, bunExe } from "harness";
+
+const xml2js = require("xml2js");
+
+describe("junit reporter", () => {
+  for (let withCIEnvironmentVariables of [false, true]) {
+    it(`should generate valid junit xml for passing tests ${withCIEnvironmentVariables ? "with CI environment variables" : ""}`, async () => {
+      const tmpDir = tempDirWithFiles("junit", {
+        "package.json": "{}",
+        "passing.test.js": `
+
+        it("should pass", () => {
+          expect(1 + 1).toBe(2);
+        });
+
+        it("second test", () => {
+          expect(1 + 1).toBe(2);
+        });
+
+        it("failing test", () => {
+          expect(1 + 1).toBe(3);
+        });
+
+        it.skip("skipped test", () => {
+          expect(1 + 1).toBe(2);
+        });
+
+        it.todo("todo test");
+
+        describe("nested describe", () => {
+          it("should pass inside nested describe", () => {
+            expect(1 + 1).toBe(2);
+          });
+
+          it("should fail inside nested describe", () => {
+            expect(1 + 1).toBe(3);
+          });
+        });
+      `,
+
+        "test-2.test.js": `
+
+        it("should pass", () => {
+          expect(1 + 1).toBe(2);
+        });
+
+        it("failing test", () => {
+          expect(1 + 1).toBe(3);
+        });
+
+        describe("nested describe", () => {
+          it("should pass inside nested describe", () => {
+            expect(1 + 1).toBe(2);
+          });
+
+          it("should fail inside nested describe", () => {
+            expect(1 + 1).toBe(3);
+          });
+        });
+      `,
+      });
+
+      let env = bunEnv;
+
+      if (withCIEnvironmentVariables) {
+        env = {
+          ...env,
+          CI_JOB_URL: "https://ci.example.com/123",
+          CI_COMMIT_SHA: "1234567890",
+        };
+      }
+
+      const junitPath = `${tmpDir}/junit.xml`;
+      const proc = spawn([bunExe(), "test", "--reporter=junit", "--reporter-outfile", junitPath], {
+        cwd: tmpDir,
+        env,
+        stdout: "inherit",
+        "stderr": "inherit",
+      });
+      await proc.exited;
+      console.log(junitPath);
+
+      expect(proc.exitCode).toBe(1);
+      const xmlContent = await file(junitPath).text();
+
+      // Parse XML to verify structure
+      const result = await new Promise((resolve, reject) => {
+        xml2js.parseString(xmlContent, (err, result) => {
+          if (err) reject(err);
+          else resolve(result);
+        });
+      });
+
+      /**
+     * ------ Vitest ------
+     * <?xml version="1.0" encoding="UTF-8" ?>
+     * <testsuites name="vitest tests" tests="11" failures="4" errors="0" time="0.176">
+     *     <testsuite name="passing.test.js" timestamp="2024-11-18T09:21:11.933Z" hostname="Jarreds-MacBook-Pro.local" tests="7" failures="2" errors="0" skipped="2" time="0.005116208">
+     *         <testcase classname="passing.test.js" name="should pass" time="0.000657541">
+     *         </testcase>
+     *         <testcase classname="passing.test.js" name="second test" time="0.000071875">
+     *         </testcase>
+     *         <testcase classname="passing.test.js" name="failing test" time="0.003308209">
+     *             <failure message="expected 2 to be 3 // Object.is equality" type="AssertionError">
+     * AssertionError: expected 2 to be 3 // Object.is equality
+     * 
+     * - Expected
+     * + Received
+     * 
+     * - 3
+     * + 2
+     * 
+     * ❯ passing.test.js:12:25
+     *             </failure>
+     *         </testcase>
+        <testcase classname="passing.test.js" name="skipped test" time="0">
+     *             <skipped/>
+     *         </testcase>
+     *         <testcase classname="passing.test.js" name="todo test" time="0">
+     *             <skipped/>
+     *         </testcase>
+     *          <testcase classname="passing.test.js" name="nested describe &gt; should pass inside nested describe" time="0.000130042">
+     *         </testcase>
+     *         <testcase classname="passing.test.js" name="nested describe &gt; should fail inside nested describe" time="0.000403125">
+     *             <failure message="expected 2 to be 3 // Object.is equality" type="AssertionError">
+     * AssertionError: expected 2 to be 3 // Object.is equality
+     * 
+     * - Expected
+     * + Received
+     * 
+     * - 3
+     * + 2
+     * 
+     * ❯ passing.test.js:27:27
+     *             </failure>
+     *         </testcase>
+    </testsuite>
+     *     <testsuite name="test-2.test.js" timestamp="2024-11-18T09:21:11.936Z" hostname="Jarreds-MacBook-Pro.local" tests="4" failures="2" errors="0" skipped="0" time="0.005188916">
+     *         <testcase classname="test-2.test.js" name="should pass" time="0.000642541">
+     *         </testcase>
+     *         <testcase classname="test-2.test.js" name="failing test" time="0.003380708">
+     *             <failure message="expected 2 to be 3 // Object.is equality" type="AssertionError">
+     * AssertionError: expected 2 to be 3 // Object.is equality
+     * 
+     * - Expected
+     * + Received
+     * 
+     * - 3
+     * + 2
+     * 
+     * ❯ test-2.test.js:8:25
+     *             </failure>
+     *         </testcase>
+     *         <testcase classname="test-2.test.js" name="nested describe &gt; should pass inside nested describe" time="0.000140541">
+     *         </testcase>
+     *         <testcase classname="test-2.test.js" name="nested describe &gt; should fail inside nested describe" time="0.000306">
+     *             <failure message="expected 2 to be 3 // Object.is equality" type="AssertionError">
+     * AssertionError: expected 2 to be 3 // Object.is equality
+     * 
+     * - Expected
+     * + Received
+     * 
+     * - 3
+     * + 2
+     * 
+     * ❯ test-2.test.js:17:27
+     *             </failure>
+     *         </testcase>
+     *     </testsuite>
+     * </testsuites>
+     */
+
+      expect(result.testsuites).toBeDefined();
+      expect(result.testsuites.testsuite).toBeDefined();
+
+      let firstSuite = result.testsuites.testsuite[0];
+      let secondSuite = result.testsuites.testsuite[1];
+
+      if (firstSuite.$.name === "passing.test.js") {
+        [firstSuite, secondSuite] = [secondSuite, firstSuite];
+      }
+
+      expect(firstSuite.testcase).toHaveLength(4);
+      expect(firstSuite.testcase[0].$.name).toBe("should pass inside nested describe");
+      expect(firstSuite.$.name).toBe("test-2.test.js");
+      expect(firstSuite.$.tests).toBe("4");
+      expect(firstSuite.$.failures).toBe("2");
+      expect(firstSuite.$.skipped).toBe("0");
+      expect(parseFloat(firstSuite.$.time)).toBeGreaterThanOrEqual(0.0);
+
+      expect(secondSuite.testcase).toHaveLength(7);
+      expect(secondSuite.testcase[0].$.name).toBe("should pass inside nested describe");
+      expect(secondSuite.$.name).toBe("passing.test.js");
+      expect(secondSuite.$.tests).toBe("7");
+      expect(secondSuite.$.failures).toBe("2");
+      expect(secondSuite.$.skipped).toBe("2");
+      expect(parseFloat(secondSuite.$.time)).toBeGreaterThanOrEqual(0.0);
+
+      expect(result.testsuites.$.tests).toBe("11");
+      expect(result.testsuites.$.failures).toBe("4");
+      expect(result.testsuites.$.skipped).toBe("2");
+      expect(parseFloat(result.testsuites.$.time)).toBeGreaterThanOrEqual(0.0);
+
+      if (withCIEnvironmentVariables) {
+        // "properties": [
+        //   {
+        //     "property": [
+        //       {
+        //         "$": {
+        //           "name": "ci",
+        //           "value": "https://ci.example.com/123"
+        //         }
+        //       },
+        //       {
+        //         "$": {
+        //           "name": "commit",
+        //           "value": "1234567890"
+        //         }
+        //       }
+        //     ]
+        //   }
+        // ],
+        expect(firstSuite.properties).toHaveLength(1);
+        expect(firstSuite.properties[0].property).toHaveLength(2);
+        expect(firstSuite.properties[0].property[0].$.name).toBe("ci");
+        expect(firstSuite.properties[0].property[0].$.value).toBe("https://ci.example.com/123");
+        expect(firstSuite.properties[0].property[1].$.name).toBe("commit");
+        expect(firstSuite.properties[0].property[1].$.value).toBe("1234567890");
+      }
+    });
+  }
+});
diff --git a/test/js/node/child_process/child_process.test.ts b/test/js/node/child_process/child_process.test.ts
index 3afb0153c1bfca..11bd16de1df9ea 100644
--- a/test/js/node/child_process/child_process.test.ts
+++ b/test/js/node/child_process/child_process.test.ts
@@ -444,3 +444,13 @@ it("it accepts stdio passthrough", async () => {
     throw e;
   }
 }, 10000);
+
+it.if(!isWindows)("spawnSync correctly reports signal codes", () => {
+  const trapCode = `
+    process.kill(process.pid, "SIGTRAP");
+  `;
+
+  const { signal } = spawnSync(bunExe(), ["-e", trapCode]);
+
+  expect(signal).toBe("SIGTRAP");
+});
diff --git a/test/js/node/fs/fs-oom.test.ts b/test/js/node/fs/fs-oom.test.ts
index c45728be5219a4..a859dc6a89c918 100644
--- a/test/js/node/fs/fs-oom.test.ts
+++ b/test/js/node/fs/fs-oom.test.ts
@@ -1,5 +1,5 @@
 import { memfd_create, setSyntheticAllocationLimitForTesting } from "bun:internal-for-testing";
-import { expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { closeSync, readFileSync, writeSync } from "fs";
 import { isLinux, isPosix } from "harness";
 setSyntheticAllocationLimitForTesting(128 * 1024 * 1024);
@@ -22,26 +22,27 @@ if (isPosix) {
 
 // memfd is linux only.
 if (isLinux) {
-  test("fs.readFileSync large file show OOM without crashing the process.", () => {
-    const memfd = memfd_create(1024 * 1024 * 256 + 1);
-    {
-      let buf = new Uint8Array(32 * 1024 * 1024);
-      for (let i = 0; i < 1024 * 1024 * 256 + 1; i += buf.byteLength) {
-        writeSync(memfd, buf, i, buf.byteLength);
-      }
-    }
-    setSyntheticAllocationLimitForTesting(128 * 1024 * 1024);
-
-    try {
-      expect(() => readFileSync(memfd)).toThrow("Out of memory");
-      Bun.gc(true);
-      expect(() => readFileSync(memfd, "utf8")).toThrow("Out of memory");
+  describe("fs.readFileSync large file show OOM without crashing the process.", () => {
+    test.each(["buffer", "utf8", "ucs2", "latin1"] as const)("%s encoding", encoding => {
+      const memfd = memfd_create(1024 * 1024 * 16 + 1);
+      (function (memfd) {
+        let buf = new Uint8Array(8 * 1024 * 1024);
+        buf.fill(42);
+        for (let i = 0; i < 1024 * 1024 * 16 + 1; i += buf.byteLength) {
+          writeSync(memfd, buf, i, buf.byteLength);
+        }
+      })(memfd);
       Bun.gc(true);
-      expect(() => readFileSync(memfd, "latin1")).toThrow("Out of memory");
-      Bun.gc(true);
-      // it is difficult in CI to test the other encodings.
-    } finally {
-      closeSync(memfd);
-    }
+      setSyntheticAllocationLimitForTesting(2 * 1024 * 1024);
+
+      try {
+        expect(() => (encoding === "buffer" ? readFileSync(memfd) : readFileSync(memfd, encoding))).toThrow(
+          "Out of memory",
+        );
+      } finally {
+        Bun.gc(true);
+        closeSync(memfd);
+      }
+    });
   });
 }
diff --git a/test/js/node/fs/fs.test.ts b/test/js/node/fs/fs.test.ts
index 6913d381919009..315bfb8e0ba151 100644
--- a/test/js/node/fs/fs.test.ts
+++ b/test/js/node/fs/fs.test.ts
@@ -597,7 +597,7 @@ describe("mkdirSync", () => {
         // @ts-expect-error
         { recursive: "lalala" },
       ),
-    ).toThrow("recursive must be a boolean");
+    ).toThrow("The \"recursive\" property must be of type boolean, got string");
   });
 });
 
diff --git a/test/js/node/http/node-http.test.ts b/test/js/node/http/node-http.test.ts
index af60305a8ca158..7400f06eb397d4 100644
--- a/test/js/node/http/node-http.test.ts
+++ b/test/js/node/http/node-http.test.ts
@@ -327,7 +327,16 @@ describe("node:http", () => {
         }
 
         // Check for body
-        if (req.method === "POST") {
+        if (req.method === "OPTIONS") {
+          req.on("data", chunk => {
+            res.write(chunk);
+          });
+
+          req.on("end", () => {
+            res.write("OPTIONS\n");
+            res.end("Hello World");
+          });
+        } else if (req.method === "POST") {
           req.on("data", chunk => {
             res.write(chunk);
           });
@@ -683,10 +692,10 @@ describe("node:http", () => {
       });
     });
 
-    it("should ignore body when method is GET/HEAD/OPTIONS", done => {
+    it("should ignore body when method is GET/HEAD", done => {
       runTest(done, (server, serverPort, done) => {
         const createDone = createDoneDotAll(done);
-        const methods = ["GET", "HEAD", "OPTIONS"];
+        const methods = ["GET", "HEAD"];
         const dones = {};
         for (const method of methods) {
           dones[method] = createDone();
@@ -710,6 +719,32 @@ describe("node:http", () => {
       });
     });
 
+    it("should have a response body when method is OPTIONS", done => {
+      runTest(done, (server, serverPort, done) => {
+        const createDone = createDoneDotAll(done);
+        const methods = ["OPTIONS"]; //keep this logic to add more methods in future
+        const dones = {};
+        for (const method of methods) {
+          dones[method] = createDone();
+        }
+        for (const method of methods) {
+          const req = request(`http://localhost:${serverPort}`, { method }, res => {
+            let data = "";
+            res.setEncoding("utf8");
+            res.on("data", chunk => {
+              data += chunk;
+            });
+            res.on("end", () => {
+              expect(data).toBe(method + "\nHello World");
+              dones[method]();
+            });
+            res.on("error", err => dones[method](err));
+          });
+          req.end();
+        }
+      });
+    });
+
     it("should return response with lowercase headers", done => {
       runTest(done, (server, serverPort, done) => {
         const req = request(`http://localhost:${serverPort}/lowerCaseHeaders`, res => {
@@ -2390,3 +2425,13 @@ it("must set headersSent to true after headers are sent when using chunk encoded
     server.close();
   }
 });
+
+it("should work when sending https.request with agent:false", async () => {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const client = https.request("https://example.com/", { agent: false });
+  client.on("error", reject);
+  client.on("close", resolve);
+  client.end();
+  await promise;
+});
+
diff --git a/test/js/node/net/node-net-server.test.ts b/test/js/node/net/node-net-server.test.ts
index 1a17db927817e8..70034749ed75a4 100644
--- a/test/js/node/net/node-net-server.test.ts
+++ b/test/js/node/net/node-net-server.test.ts
@@ -3,6 +3,7 @@ import { AddressInfo, createServer, Server, Socket } from "net";
 import { createTest } from "node-harness";
 import { tmpdir } from "os";
 import { join } from "path";
+import { once } from "node:events";
 
 const { describe, expect, it, createCallCheckCtx } = createTest(import.meta.path);
 
@@ -565,4 +566,27 @@ describe("net.createServer events", () => {
       }).catch(closeAndFail);
     });
   });
+
+  it("#8374", async () => {
+    const server = createServer();
+    const socketPath = join(tmpdir(), "test-unix-socket");
+
+    server.listen({ path: socketPath });
+    await once(server, "listening");
+
+    try {
+      const address = server.address() as string;
+      expect(address).toBe(socketPath);
+
+      const client = await Bun.connect({
+        unix: socketPath,
+        socket: {
+          data() {},
+        },
+      });
+      client.end();
+    } finally {
+      server.close();
+    }
+  });
 });
diff --git a/test/js/node/net/node-net.test.ts b/test/js/node/net/node-net.test.ts
index 9e4aa7ffc25b9d..ef56deafe9c59c 100644
--- a/test/js/node/net/node-net.test.ts
+++ b/test/js/node/net/node-net.test.ts
@@ -563,48 +563,57 @@ it("should not hang after destroy", async () => {
   }
 });
 
-it.if(isWindows)("should work with named pipes", async () => {
-  async function test(pipe_name: string) {
-    const { promise: messageReceived, resolve: resolveMessageReceived } = Promise.withResolvers();
-    const { promise: clientReceived, resolve: resolveClientReceived } = Promise.withResolvers();
-    let client: ReturnType<typeof connect> | null = null;
-    let server: ReturnType<typeof createServer> | null = null;
-    try {
-      server = createServer(socket => {
-        socket.on("data", data => {
-          const message = data.toString();
-          socket.end("Goodbye World!");
-          resolveMessageReceived(message);
+it.if(isWindows)(
+  "should work with named pipes",
+  async () => {
+    async function test(pipe_name: string) {
+      const { promise: messageReceived, resolve: resolveMessageReceived } = Promise.withResolvers();
+      const { promise: clientReceived, resolve: resolveClientReceived } = Promise.withResolvers();
+      let client: ReturnType<typeof connect> | null = null;
+      let server: ReturnType<typeof createServer> | null = null;
+      try {
+        server = createServer(socket => {
+          socket.on("data", data => {
+            const message = data.toString();
+            socket.end("Goodbye World!");
+            resolveMessageReceived(message);
+          });
         });
-      });
 
-      server.listen(pipe_name);
-      client = connect(pipe_name).on("data", data => {
-        const message = data.toString();
-        resolveClientReceived(message);
-      });
+        server.listen(pipe_name);
+        client = connect(pipe_name).on("data", data => {
+          const message = data.toString();
+          resolveClientReceived(message);
+        });
 
-      client?.write("Hello World!");
-      const message = await messageReceived;
-      expect(message).toBe("Hello World!");
-      const client_message = await clientReceived;
-      expect(client_message).toBe("Goodbye World!");
-    } finally {
-      client?.destroy();
-      server?.close();
+        client?.write("Hello World!");
+        const message = await messageReceived;
+        expect(message).toBe("Hello World!");
+        const client_message = await clientReceived;
+        expect(client_message).toBe("Goodbye World!");
+      } finally {
+        client?.destroy();
+        server?.close();
+      }
     }
-  }
 
-  const batch = [];
-  const before = heapStats().objectTypeCounts.TLSSocket || 0;
-  for (let i = 0; i < 200; i++) {
-    batch.push(test(`\\\\.\\pipe\\test\\${randomUUID()}`));
-    batch.push(test(`\\\\?\\pipe\\test\\${randomUUID()}`));
-    if (i % 50 === 0) {
-      await Promise.all(batch);
-      batch.length = 0;
+    const batch = [];
+    const before = heapStats().objectTypeCounts.TLSSocket || 0;
+    for (let i = 0; i < 100; i++) {
+      batch.push(test(`\\\\.\\pipe\\test\\${randomUUID()}`));
+      batch.push(test(`\\\\?\\pipe\\test\\${randomUUID()}`));
+      batch.push(test(`//?/pipe/test/${randomUUID()}`));
+      batch.push(test(`//./pipe/test/${randomUUID()}`));
+      batch.push(test(`/\\./pipe/test/${randomUUID()}`));
+      batch.push(test(`/\\./pipe\\test/${randomUUID()}`));
+      batch.push(test(`\\/.\\pipe/test\\${randomUUID()}`));
+      if (i % 50 === 0) {
+        await Promise.all(batch);
+        batch.length = 0;
+      }
     }
-  }
-  await Promise.all(batch);
-  expectMaxObjectTypeCount(expect, "TCPSocket", before);
-});
+    await Promise.all(batch);
+    expectMaxObjectTypeCount(expect, "TCPSocket", before);
+  },
+  20_000,
+);
diff --git a/test/js/node/path/parse-format.test.js b/test/js/node/path/parse-format.test.js
index 2534e24b6928fe..4e91eb7cabef62 100644
--- a/test/js/node/path/parse-format.test.js
+++ b/test/js/node/path/parse-format.test.js
@@ -210,7 +210,7 @@ describe("path.parse", () => {
             //
             // While Node's error message is:
             //   The "pathObject" argument must be of type object. Received null
-            message: `"pathObject" property must be of type object, got ${typeof pathObject}`,
+            message: `The "pathObject" property must be of type object, got ${typeof pathObject}`,
           },
         );
       });
diff --git a/test/js/node/process/call-raise.js b/test/js/node/process/call-raise.js
index 898906759e87d9..5b95f9ec44f05b 100644
--- a/test/js/node/process/call-raise.js
+++ b/test/js/node/process/call-raise.js
@@ -1,10 +1,10 @@
 import { dlopen } from "bun:ffi";
+import { libcPathForDlopen } from "harness";
 
 var lazyRaise;
 export function raise(signal) {
   if (!lazyRaise) {
-    const suffix = process.platform === "darwin" ? "dylib" : "so.6";
-    lazyRaise = dlopen(`libc.${suffix}`, {
+    lazyRaise = dlopen(libcPathForDlopen(), {
       raise: {
         args: ["int"],
         returns: "int",
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index 241e293956dcfa..a2dac046fa6dbb 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -3,6 +3,7 @@ import { describe, expect, it } from "bun:test";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { bunEnv, bunExe, isWindows, tmpdirSync } from "harness";
 import { basename, join, resolve } from "path";
+import { familySync } from "detect-libc";
 
 expect.extend({
   toRunInlineFixture(input) {
@@ -135,8 +136,9 @@ it("process.release", () => {
   expect(process.release.name).toBe("node");
   const platform = process.platform == "win32" ? "windows" : process.platform;
   const arch = { arm64: "aarch64", x64: "x64" }[process.arch] || process.arch;
-  const nonbaseline = `https://github.com/oven-sh/bun/releases/download/bun-v${process.versions.bun}/bun-${platform}-${arch}.zip`;
-  const baseline = `https://github.com/oven-sh/bun/releases/download/bun-v${process.versions.bun}/bun-${platform}-${arch}-baseline.zip`;
+  const abi = familySync() === "musl" ? "-musl" : "";
+  const nonbaseline = `https://github.com/oven-sh/bun/releases/download/bun-v${process.versions.bun}/bun-${platform}-${arch}${abi}.zip`;
+  const baseline = `https://github.com/oven-sh/bun/releases/download/bun-v${process.versions.bun}/bun-${platform}-${arch}${abi}-baseline.zip`;
 
   expect(process.release.sourceUrl).toBeOneOf([nonbaseline, baseline]);
 });
diff --git a/test/js/node/test/parallel/pipe-abstract-socket.test.js b/test/js/node/test/parallel/pipe-abstract-socket.test.js
index 57a49d09ae0be1..934108f4c536e4 100644
--- a/test/js/node/test/parallel/pipe-abstract-socket.test.js
+++ b/test/js/node/test/parallel/pipe-abstract-socket.test.js
@@ -12,47 +12,56 @@ if (!isLinux) {
 } else {
   describe("Abstract Unix socket tests", () => {
     const path = "\0abstract";
-    const expectedErrorMessage = "can not set readableAll or writableAllt to true when path is abstract unix socket";
+    const expectedErrorMessage = "The argument 'options' can not set readableAll or writableAll to true when path is abstract unix socket. Received";
 
     test("throws when setting readableAll to true", () => {
+      const options = {
+        path,
+        readableAll: true,
+      };
+
       expect(() => {
         const server = net.createServer(jest.fn());
-        server.listen({
-          path,
-          readableAll: true,
-        });
+        server.listen(options);
       }).toThrow(
         expect.objectContaining({
-          message: expect.any(String),
+          message: `${expectedErrorMessage} ${JSON.stringify(options)}`,
+          code: "ERR_INVALID_ARG_VALUE",
         }),
       );
     });
 
     test("throws when setting writableAll to true", () => {
+      const options = {
+        path,
+        writableAll: true,
+      } ;
+
       expect(() => {
         const server = net.createServer(jest.fn());
-        server.listen({
-          path,
-          writableAll: true,
-        });
+        server.listen(options);
       }).toThrow(
         expect.objectContaining({
-          message: expect.any(String),
+          message: `${expectedErrorMessage} ${JSON.stringify(options)}`,
+          code: "ERR_INVALID_ARG_VALUE",
         }),
       );
     });
 
     test("throws when setting both readableAll and writableAll to true", () => {
+      const options = {
+        path,
+        readableAll: true,
+        writableAll: true,
+      };
+
       expect(() => {
         const server = net.createServer(jest.fn());
-        server.listen({
-          path,
-          readableAll: true,
-          writableAll: true,
-        });
+        server.listen(options);
       }).toThrow(
         expect.objectContaining({
-          message: expect.any(String),
+          message: `${expectedErrorMessage} ${JSON.stringify(options)}`,
+          code: "ERR_INVALID_ARG_VALUE",
         }),
       );
     });
diff --git a/test/js/sql/sql-fixture-ref.ts b/test/js/sql/sql-fixture-ref.ts
new file mode 100644
index 00000000000000..af8f52dafc0b79
--- /dev/null
+++ b/test/js/sql/sql-fixture-ref.ts
@@ -0,0 +1,21 @@
+// This test passes by printing
+// 1
+// 2
+// and exiting with code 0.
+import { sql } from "bun";
+process.exitCode = 1;
+
+async function first() {
+  const result = await sql`select 1 as x`;
+  console.log(result[0].x);
+}
+
+async function yo() {
+  const result2 = await sql`select 2 as x`;
+  console.log(result2[0].x);
+  process.exitCode = 0;
+}
+first();
+Bun.gc(true);
+yo();
+Bun.gc(true);
diff --git a/test/js/sql/sql.test.ts b/test/js/sql/sql.test.ts
index cef6943439e960..8c0089c76032fd 100644
--- a/test/js/sql/sql.test.ts
+++ b/test/js/sql/sql.test.ts
@@ -1,6 +1,8 @@
 import { postgres, sql } from "bun:sql";
 import { expect, test } from "bun:test";
-import { isCI } from "harness";
+import { $ } from "bun";
+import { bunExe, isCI, withoutAggressiveGC } from "harness";
+import path from "path";
 
 if (!isCI) {
   require("./bootstrap.js");
@@ -100,12 +102,13 @@ if (!isCI) {
     expect((await sql`select ${null} as x`)[0].x).toBeNull();
   });
 
-  test("Unsigned Integer", async () => {
+  test.todo("Unsigned Integer", async () => {
     expect((await sql`select ${0x7fffffff + 2} as x`)[0].x).toBe(0x7fffffff + 2);
   });
 
   test("Signed Integer", async () => {
     expect((await sql`select ${-1} as x`)[0].x).toBe(-1);
+    expect((await sql`select ${1} as x`)[0].x).toBe(1);
   });
 
   test("Double", async () => {
@@ -120,12 +123,18 @@ if (!isCI) {
 
   test("Boolean true", async () => expect((await sql`select ${true} as x`)[0].x).toBe(true));
 
-  test("Date", async () => {
+  test("Date (timestamp)", async () => {
     const now = new Date();
     const then = (await sql`select ${now}::timestamp as x`)[0].x;
     expect(then).toEqual(now);
   });
 
+  test("Date (timestamptz)", async () => {
+    const now = new Date();
+    const then = (await sql`select ${now}::timestamptz as x`)[0].x;
+    expect(then).toEqual(now);
+  });
+
   // t("Json", async () => {
   //   const x = (await sql`select ${sql.json({ a: "hello", b: 42 })} as x`)[0].x;
   //   return ["hello,42", [x.a, x.b].join()];
@@ -142,6 +151,23 @@ if (!isCI) {
     expect([x.a, x.b].join(",")).toBe("hello,42");
   });
 
+  test("bulk insert nested sql()", async () => {
+    await sql`create table users (name text, age int)`;
+    const users = [
+      { name: "Alice", age: 25 },
+      { name: "Bob", age: 30 },
+    ];
+    try {
+      const result = await sql`insert into users ${sql(users)} RETURNING *`;
+      expect(result).toEqual([
+        { name: "Alice", age: 25 },
+        { name: "Bob", age: 30 },
+      ]);
+    } finally {
+      await sql`drop table users`;
+    }
+  });
+
   // t("Empty array", async () => [true, Array.isArray((await sql`select ${sql.array([], 1009)} as x`)[0].x)]);
 
   test("string arg with ::int -> Array<int>", async () =>
@@ -991,16 +1017,46 @@ if (!isCI) {
   //   }`.catch(e => e.code)), await sql`drop table test`]
   // })
 
-  test("let postgres do implicit cast of unknown types", async () => {
+  test("timestamp with time zone is consistent", async () => {
     await sql`create table test (x timestamp with time zone)`;
     try {
-      const [{ x }] = await sql`insert into test values (${new Date().toISOString()}) returning *`;
+      const date = new Date();
+      const [{ x }] = await sql`insert into test values (${date}) returning *`;
       expect(x instanceof Date).toBe(true);
+      expect(x.toISOString()).toBe(date.toISOString());
     } finally {
       await sql`drop table test`;
     }
   });
 
+  test("timestamp is consistent", async () => {
+    await sql`create table test2 (x timestamp)`;
+    try {
+      const date = new Date();
+      const [{ x }] = await sql`insert into test2 values (${date}) returning *`;
+      expect(x instanceof Date).toBe(true);
+      expect(x.toISOString()).toBe(date.toISOString());
+    } finally {
+      await sql`drop table test2`;
+    }
+  });
+
+  test(
+    "let postgres do implicit cast of unknown types",
+    async () => {
+      await sql`create table test3 (x timestamp with time zone)`;
+      try {
+        const date = new Date("2024-01-01T00:00:00Z");
+        const [{ x }] = await sql`insert into test3 values (${date.toISOString()}) returning *`;
+        expect(x instanceof Date).toBe(true);
+        expect(x.toISOString()).toBe(date.toISOString());
+      } finally {
+        await sql`drop table test3`;
+      }
+    },
+    { timeout: 1000000 },
+  );
+
   // t('only allows one statement', async() =>
   //   ['42601', await sql`select 1; select 2`.catch(e => e.code)]
   // )
@@ -1580,9 +1636,17 @@ if (!isCI) {
   //   return [1, (await sql`select 1 as x`)[0].x]
   // })
 
-  // t('Big result', async() => {
-  //   return [100000, (await sql`select * from generate_series(1, 100000)`).count]
-  // })
+  test("Big result", async () => {
+    const result = await sql`select * from generate_series(1, 100000)`;
+    expect(result.count).toBe(100000);
+    let i = 1;
+
+    for (const row of result) {
+      if (row.generate_series !== i++) {
+        throw new Error(`Row out of order at index ${i - 1}`);
+      }
+    }
+  });
 
   // t('Debug', async() => {
   //   let result
@@ -1601,15 +1665,14 @@ if (!isCI) {
   //   typeof (await sql`select 9223372036854777 as x`)[0].x
   // ])
 
-  // t('int is returned as Number', async() => [
-  //   'number',
-  //   typeof (await sql`select 123 as x`)[0].x
-  // ])
+  test("int is returned as Number", async () => {
+    expect((await sql`select 123 as x`)[0].x).toBe(123);
+  });
 
-  // t('numeric is returned as string', async() => [
-  //   'string',
-  //   typeof (await sql`select 1.2 as x`)[0].x
-  // ])
+  test("numeric is returned as string", async () => {
+    const result = (await sql`select 1.2 as x`)[0].x;
+    expect(result).toBe("1.2");
+  });
 
   // t('Async stack trace', async() => {
   //   const sql = postgres({ ...options, debug: false })
@@ -1733,9 +1796,9 @@ if (!isCI) {
   //   [true, (await sql`bad keyword`.catch(e => e)) instanceof sql.PostgresError]
   // )
 
-  // t('Result has columns spec', async() =>
-  //   ['x', (await sql`select 1 as x`).columns[0].name]
-  // )
+  test.todo("Result has columns spec", async () => {
+    expect((await sql`select 1 as x`).columns[0].name).toBe("x");
+  });
 
   // t('forEach has result as second argument', async() => {
   //   let x
@@ -1921,9 +1984,9 @@ if (!isCI) {
   //   ]
   // })
 
-  // t('Array returns rows as arrays of columns', async() => {
-  //   return [(await sql`select 1`.values())[0][0], 1]
-  // })
+  test("Array returns rows as arrays of columns", async () => {
+    return [(await sql`select 1`.values())[0][0], 1];
+  });
 
   // t('Copy read', async() => {
   //   const result = []
@@ -2586,4 +2649,11 @@ if (!isCI) {
   //     xs.map(x => x.x).join('')
   //   ]
   // })
+
+  test("keeps process alive when it should", async () => {
+    const file = path.posix.join(__dirname, "sql-fixture-ref.ts");
+    const result = await $`DATABASE_URL=${process.env.DATABASE_URL} ${bunExe()} ${file}`;
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString().split("\n")).toEqual(["1", "2", ""]);
+  });
 }
diff --git a/test/js/sql/tls-sql.test.ts b/test/js/sql/tls-sql.test.ts
new file mode 100644
index 00000000000000..2bc99bd3ad2d40
--- /dev/null
+++ b/test/js/sql/tls-sql.test.ts
@@ -0,0 +1,23 @@
+import { test, expect } from "bun:test";
+import { getSecret } from "harness";
+import { sql as SQL } from "bun";
+
+const TLS_POSTGRES_DATABASE_URL = getSecret("TLS_POSTGRES_DATABASE_URL");
+
+test("tls (explicit)", async () => {
+  const sql = new SQL({
+    url: TLS_POSTGRES_DATABASE_URL!,
+    tls: true,
+    adapter: "postgresql",
+  });
+
+  const [{ one, two }] = await sql`SELECT 1 as one, '2' as two`;
+  expect(one).toBe(1);
+  expect(two).toBe("2");
+});
+
+test("tls (implicit)", async () => {
+  const [{ one, two }] = await SQL`SELECT 1 as one, '2' as two`;
+  expect(one).toBe(1);
+  expect(two).toBe("2");
+});
diff --git a/test/js/third_party/grpc-js/fixtures/ca.pem b/test/js/third_party/grpc-js/fixtures/ca.pem
index 6c8511a73c68ac..3f292fed8b6943 100644
--- a/test/js/third_party/grpc-js/fixtures/ca.pem
+++ b/test/js/third_party/grpc-js/fixtures/ca.pem
@@ -1,15 +1,33 @@
 -----BEGIN CERTIFICATE-----
-MIICSjCCAbOgAwIBAgIJAJHGGR4dGioHMA0GCSqGSIb3DQEBCwUAMFYxCzAJBgNV
-BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
-aWRnaXRzIFB0eSBMdGQxDzANBgNVBAMTBnRlc3RjYTAeFw0xNDExMTEyMjMxMjla
-Fw0yNDExMDgyMjMxMjlaMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0
-YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMT
-BnRlc3RjYTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwEDfBV5MYdlHVHJ7
-+L4nxrZy7mBfAVXpOc5vMYztssUI7mL2/iYujiIXM+weZYNTEpLdjyJdu7R5gGUu
-g1jSVK/EPHfc74O7AyZU34PNIP4Sh33N+/A5YexrNgJlPY+E3GdVYi4ldWJjgkAd
-Qah2PH5ACLrIIC6tRka9hcaBlIECAwEAAaMgMB4wDAYDVR0TBAUwAwEB/zAOBgNV
-HQ8BAf8EBAMCAgQwDQYJKoZIhvcNAQELBQADgYEAHzC7jdYlzAVmddi/gdAeKPau
-sPBG/C2HCWqHzpCUHcKuvMzDVkY/MP2o6JIW2DBbY64bO/FceExhjcykgaYtCH/m
-oIU63+CFOTtR7otyQAWHqXa7q4SbCDlG7DyRFxqG0txPtGvy12lgldA2+RgcigQG
-Dfcog5wrJytaQ6UA0wE=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=
 -----END CERTIFICATE-----
diff --git a/test/js/third_party/grpc-js/fixtures/server1.key b/test/js/third_party/grpc-js/fixtures/server1.key
index 143a5b87658d5c..8218f2933bb036 100644
--- a/test/js/third_party/grpc-js/fixtures/server1.key
+++ b/test/js/third_party/grpc-js/fixtures/server1.key
@@ -1,16 +1,52 @@
 -----BEGIN PRIVATE KEY-----
-MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAOHDFScoLCVJpYDD
-M4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1BgzkWF+slf
-3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd9N8YwbBY
-AckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAECgYAn7qGnM2vbjJNBm0VZCkOkTIWm
-V10okw7EPJrdL2mkre9NasghNXbE1y5zDshx5Nt3KsazKOxTT8d0Jwh/3KbaN+YY
-tTCbKGW0pXDRBhwUHRcuRzScjli8Rih5UOCiZkhefUTcRb6xIhZJuQy71tjaSy0p
-dHZRmYyBYO2YEQ8xoQJBAPrJPhMBkzmEYFtyIEqAxQ/o/A6E+E4w8i+KM7nQCK7q
-K4JXzyXVAjLfyBZWHGM2uro/fjqPggGD6QH1qXCkI4MCQQDmdKeb2TrKRh5BY1LR
-81aJGKcJ2XbcDu6wMZK4oqWbTX2KiYn9GB0woM6nSr/Y6iy1u145YzYxEV/iMwff
-DJULAkB8B2MnyzOg0pNFJqBJuH29bKCcHa8gHJzqXhNO5lAlEbMK95p/P2Wi+4Hd
-aiEIAF1BF326QJcvYKmwSmrORp85AkAlSNxRJ50OWrfMZnBgzVjDx3xG6KsFQVk2
-ol6VhqL6dFgKUORFUWBvnKSyhjJxurlPEahV6oo6+A+mPhFY8eUvAkAZQyTdupP3
-XEFQKctGz+9+gKkemDp7LBBMEMBXrGTLPhpEfcjv/7KPdnFHYmhYeBTBnuVmTVWe
-F98XJ7tIFfJq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 -----END PRIVATE KEY-----
diff --git a/test/js/third_party/grpc-js/fixtures/server1.pem b/test/js/third_party/grpc-js/fixtures/server1.pem
index f3d43fcc5beadd..3f292fed8b6943 100644
--- a/test/js/third_party/grpc-js/fixtures/server1.pem
+++ b/test/js/third_party/grpc-js/fixtures/server1.pem
@@ -1,16 +1,33 @@
 -----BEGIN CERTIFICATE-----
-MIICnDCCAgWgAwIBAgIBBzANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJBVTET
-MBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQ
-dHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2EwHhcNMTUxMTA0MDIyMDI0WhcNMjUxMTAx
-MDIyMDI0WjBlMQswCQYDVQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNV
-BAcTB0NoaWNhZ28xFTATBgNVBAoTDEV4YW1wbGUsIENvLjEaMBgGA1UEAxQRKi50
-ZXN0Lmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAOHDFSco
-LCVJpYDDM4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1Bg
-zkWF+slf3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd
-9N8YwbBYAckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAGjazBpMAkGA1UdEwQCMAAw
-CwYDVR0PBAQDAgXgME8GA1UdEQRIMEaCECoudGVzdC5nb29nbGUuZnKCGHdhdGVy
-em9vaS50ZXN0Lmdvb2dsZS5iZYISKi50ZXN0LnlvdXR1YmUuY29thwTAqAEDMA0G
-CSqGSIb3DQEBCwUAA4GBAJFXVifQNub1LUP4JlnX5lXNlo8FxZ2a12AFQs+bzoJ6
-hM044EDjqyxUqSbVePK0ni3w1fHQB5rY9yYC5f8G7aqqTY1QOhoUk8ZTSTRpnkTh
-y4jjdvTZeLDVBlueZUTDRmy2feY5aZIU18vFDK08dTG0A87pppuv1LNIR3loveU8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=
 -----END CERTIFICATE-----
diff --git a/test/mkfifo.ts b/test/mkfifo.ts
index 1fd04572399c09..18956e845c12b8 100644
--- a/test/mkfifo.ts
+++ b/test/mkfifo.ts
@@ -1,10 +1,10 @@
 import { dlopen, ptr } from "bun:ffi";
+import { libcPathForDlopen } from "harness";
 
 var lazyMkfifo: any;
 export function mkfifo(path: string, permissions: number = 0o666): void {
   if (!lazyMkfifo) {
-    const suffix = process.platform === "darwin" ? "dylib" : "so.6";
-    lazyMkfifo = dlopen(`libc.${suffix}`, {
+    lazyMkfifo = dlopen(libcPathForDlopen(), {
       mkfifo: {
         args: ["ptr", "i32"],
         returns: "i32",
diff --git a/test/package.json b/test/package.json
index 3f75a236a42d80..b360be82bbb2e8 100644
--- a/test/package.json
+++ b/test/package.json
@@ -65,6 +65,7 @@
     "vitest": "0.32.2",
     "webpack": "5.88.0",
     "webpack-cli": "4.7.2",
+    "xml2js": "0.6.2",
     "yargs": "17.7.2"
   },
   "private": true,
diff --git a/test/regression/issue/015201.test.ts b/test/regression/issue/015201.test.ts
new file mode 100644
index 00000000000000..ab9ce799dd65b1
--- /dev/null
+++ b/test/regression/issue/015201.test.ts
@@ -0,0 +1,6 @@
+import { promisify } from "util";
+
+test("abc", () => {
+  const setTimeout = promisify(globalThis.setTimeout);
+  setTimeout(1, "ok").then(console.log);
+});
diff --git a/test/regression/issue/14976/14976.test.ts b/test/regression/issue/14976/14976.test.ts
new file mode 100644
index 00000000000000..37e7c72df0672e
--- /dev/null
+++ b/test/regression/issue/14976/14976.test.ts
@@ -0,0 +1,77 @@
+import { mile𐃘add1 } from "./import_target";
+import { mile𐃘add1 as m } from "./import_target";
+import * as i from "./import_target";
+import { test, expect } from "bun:test";
+import { $ } from "bun";
+import { bunExe, tempDirWithFiles } from "harness";
+
+test("unicode imports", () => {
+  expect(mile𐃘add1(25)).toBe(26);
+  expect(i.mile𐃘add1(25)).toBe(26);
+  expect(m(25)).toBe(26);
+});
+
+test("more unicode imports", async () => {
+  const dir = tempDirWithFiles("more-unicode-imports", {
+    "mod_importer.ts": `
+      import { nထme as nထme𐃘1 } from "./mod\\u1011.ts";
+      import { nထme as nထme𐃘2 } from "./modထ.ts";
+
+      console.log(nထme𐃘1, nထme𐃘2);
+    `,
+    "modထ.ts": `
+      export const nထme = "𐃘1";
+    `,
+  });
+  expect((await $`${bunExe()} run ${dir}/mod_importer.ts`.text()).trim()).toBe("𐃘1 𐃘1");
+  console.log(await $`${bunExe()} build --target=bun ${dir}/mod_importer.ts`.text());
+  console.log(await $`${bunExe()} build --target=node ${dir}/mod_importer.ts`.text());
+});
+
+// prettier-ignore
+test("escaped unicode variable name", () => {
+  let mile\u{100d8}value = 36;
+  expect(mile𐃘value).toBe(36);
+  expect(mile\u{100d8}value).toBe(36);
+});
+
+test("bun build --target=bun outputs only ascii", async () => {
+  const build_result = await Bun.build({
+    entrypoints: [import.meta.dirname + "/import_target.ts"],
+    target: "bun",
+  });
+  expect(build_result.success).toBe(true);
+  expect(build_result.outputs.length).toBe(1);
+  for (const byte of new Uint8Array(await build_result.outputs[0].arrayBuffer())) {
+    expect(byte).toBeLessThan(0x80);
+  }
+});
+
+test("string escapes", () => {
+  expect({ ["mile𐃘add1"]: 1 }?.mile𐃘add1).toBe(1);
+  expect(`\\ ' " \` $ 𐃘`).toBe([0x5c, 0x27, 0x22, 0x60, 0x24, 0x100d8].map(c => String.fromCodePoint(c)).join(" "));
+  expect({ "\\": 1 }[String.fromCodePoint(0x5c)]).toBe(1);
+  const tag = (a: TemplateStringsArray) => a.raw;
+  expect(tag`$one \$two`).toEqual(["$one \\$two"]);
+});
+
+test("constant-folded equals doesn't lie", async () => {
+  expect(
+    "\n" ===
+      `
+`,
+  ).toBe(true);
+  // prettier-ignore
+  expect(
+    "\a\n" ===
+      `a
+`,
+  ).toBe(true);
+  // prettier-ignore
+  console.log("\"" === '"');
+});
+
+test.skip("template literal raw property with unicode in an ascii-only build", async () => {
+  expect(String.raw`你好𐃘\\`).toBe("你好𐃘\\\\");
+  expect((await $`echo 你好𐃘`.text()).trim()).toBe("你好𐃘");
+});
diff --git a/test/regression/issue/14976/import_target.ts b/test/regression/issue/14976/import_target.ts
new file mode 100644
index 00000000000000..b1b9a61f149c9f
--- /dev/null
+++ b/test/regression/issue/14976/import_target.ts
@@ -0,0 +1,2 @@
+"use𐃘unicode";
+export const mile𐃘add1 = (int: number) => int + 1;